Actor.h

Go to the documentation of this file.

#pragma once
 
#include "../Base.h"
 
struct FChatMessage
{
    FString SenderName;
    FString SenderSteamName;
    FString SenderTribeName;
    unsigned int SenderId;
    FString Message;
    FString Receiver;
    int SenderTeamIndex;
    long double ReceivedTime;
    TEnumAsByte<EChatSendMode::Type> SendMode;
    unsigned int RadioFrequency;
    TEnumAsByte<enum EChatType::Type> ChatType;
    UTexture2D* SenderIcon;
    FString UserId;
 
    FChatMessage()
        : SenderName(""),
        SenderSteamName(""),
        SenderTribeName(""),
        SenderId(0),
        Message(""),
        Receiver(""),
        SenderTeamIndex(0),
        ReceivedTime(-1),
        SendMode(EChatSendMode::GlobalChat),
        RadioFrequency(0),
        ChatType(EChatType::GlobalChat),
        SenderIcon(nullptr),
        UserId("")
    {
    }
 
    FChatMessage(FChatMessage* __that) { NativeCall<void, FChatMessage *>(this, "FChatMessage.FChatMessage", __that); }
    FChatMessage* operator=(FChatMessage* __that) { return NativeCall<FChatMessage *, FChatMessage *>(this, "FChatMessage.operator=", __that); }
};
 
struct FUniqueNetIdRepl
{
    TSharedPtr<FUniqueNetId> UniqueNetId;
};
 
struct FWeightedObjectList
{
    TArray<float> Weights;
    TArray<UObject*> AssociatedObjects;
};
 
struct FActorSpawnParameters
{
    FActorSpawnParameters()
        : Name()
        , Template(NULL)
        , Owner(NULL)
        , Instigator(NULL)
        , OverrideLevel(NULL)
        , bNoCollisionFail(0)
        , bRemoteOwned(false)
        , bNoFail(false)
        , bDeferruction(false)
        , bAllowDuringructionScript(false)
        , bDeferBeginPlay(0)
        , ExtraSpawnData(0)
        , ObjectFlags(EObjectFlags::RF_Transactional)
        , AttachToComponent(nullptr)
    {
    }
 
    FName Name;
    AActor *Template;
    AActor *Owner;
    APawn *Instigator;
    ULevel *OverrideLevel;
    unsigned __int32 bNoCollisionFail : 1;
    unsigned __int32 bRemoteOwned : 1;
    unsigned __int32 bNoFail : 1;
    unsigned __int32 bDeferruction : 1;
    unsigned __int32 bAllowDuringructionScript : 1;
    unsigned __int32 bDeferBeginPlay : 1;
    int ExtraSpawnData;
    EObjectFlags ObjectFlags;
    USceneComponent *AttachToComponent;
    FName AttachToBoneName;
};
 
struct FItemSetup
{
    TSubclassOf<UPrimalItem> ItemType;
    FString ItemBlueprintPath;
    float MinQuality;
    float MaxQuality;
    int Quantity;
    __int8 bAutoEquip : 1;
    __int8 bDontStack : 1;
    __int8 bForceBlueprint : 1;
};
 
 
struct __declspec(align(8)) FDinoSetup
{
    TSubclassOf<APrimalDinoCharacter> DinoType;
    FString DinoBlueprintPath;
    FString DinoName;
    int DinoLevel;
    char BasePointsPerStat[12];
    char PlayerAddedPointsPerStat[12];
    FVector SpawnOffset;
    TEnumAsByte<enum EDinoTamedOrder::Type> DinoState;
    TArray<TEnumAsByte<enum EPrimalCharacterStatusValue::Type>> PrioritizeStats;
    TArray<FItemSetup> TamedDinoInventory;
    TSubclassOf<UPrimalItem> SaddleType;
    FString SaddleBlueprintPath;
    float SaddleQuality;
    float SaddleMinRandomQuality;
    unsigned __int32 bIsTamed : 1;
    unsigned __int32 bIgnoreMaxTameLimit : 1;
    unsigned __int32 bBlockTamedDialog : 1;
    unsigned __int32 bAutoEquipSaddle : 1;
    unsigned __int32 bUseFixedSpawnLevel : 1;
};
 
struct FPlayerDeathReason
{
    int PlayerID;
    FString DeathReason;
    long double DiedAtTime;
};
 
struct __declspec(align(8)) FPrimalPlayerCharacterConfigStruct
{
    __int8 bIsFemale : 1;
    FLinearColor BodyColors[4];
    FLinearColor OverrideHeadHairColor;
    FLinearColor OverrideFacialHairColor;
    char FacialHairIndex;
    char HeadHairIndex;
    FString PlayerCharacterName;
    float RawBoneModifiers[22];
    int PlayerSpawnRegionIndex;
 
    FPrimalPlayerCharacterConfigStruct()
    {
        FLinearColor black = FLinearColor(0, 0, 0);
        bIsFemale = false;
        for (int i = 0; i < 4; ++i)
            BodyColors[i] = black;
        OverrideHeadHairColor = black;
        OverrideFacialHairColor = black;
        PlayerSpawnRegionIndex = 0;
        PlayerCharacterName = L"Survivor";
        FMemory::Memzero(&RawBoneModifiers, sizeof(RawBoneModifiers));
    }
};
 
struct FPrimalPlayerCharacterConfigStructReplicated
{
    uint8 bIsFemale : 1;
    FLinearColor BodyColors[4];
    FString PlayerCharacterName;
    float RawBoneModifiers[22];
    int32 PlayerSpawnRegionIndex;
 
    FPrimalPlayerCharacterConfigStructReplicated()
    {
        FLinearColor black = FLinearColor(0, 0, 0);
        bIsFemale = false;
        for (int i = 0; i < 4; ++i)
            BodyColors[i] = black;
        PlayerSpawnRegionIndex = 0;
        PlayerCharacterName = L"Survivor";
        FMemory::Memzero(&RawBoneModifiers, sizeof(RawBoneModifiers));
    }
 
    FPrimalPlayerCharacterConfigStructReplicated(const FPrimalPlayerCharacterConfigStruct& original)
    {
        bIsFemale = original.bIsFemale;
        PlayerCharacterName = original.PlayerCharacterName;
        PlayerSpawnRegionIndex = original.PlayerSpawnRegionIndex;
        FMemory::Memcpy(&BodyColors, &original.BodyColors, sizeof(BodyColors));
        FMemory::Memcpy(&RawBoneModifiers, &original.RawBoneModifiers, sizeof(RawBoneModifiers));
    }
 
    FPrimalPlayerCharacterConfigStruct GetPlayerCharacterConfig()
    {
        FPrimalPlayerCharacterConfigStruct toReturn;
        toReturn.bIsFemale = bIsFemale;
        toReturn.PlayerCharacterName = PlayerCharacterName;
        toReturn.PlayerSpawnRegionIndex = PlayerSpawnRegionIndex;
        FMemory::Memcpy(&toReturn.BodyColors, &BodyColors, sizeof(BodyColors));
        FMemory::Memcpy(&toReturn.RawBoneModifiers, &RawBoneModifiers, sizeof(RawBoneModifiers));
        return toReturn;
    }
};
 
struct FPrimalCharacterStatusValueModifier
{
    EPrimalCharacterStatusValue::Type ValueType;
    EPrimalCharacterStatusValue::Type StopOnValueNearMax;
    float AmountToAdd;
    float BaseAmountToAdd;
    float SpeedToAdd;
    bool bContinueOnUnchangedValue;
    bool bSetValue;
    bool bSetAdditionalValue;
    bool bMakeUntameable;
    int StatusValueModifierDescriptionIndex;
};
 
struct FArkTributeEntity
{
    int UploadTime;
};
 
struct FARKTributeDino : FArkTributeEntity
{
    FString DinoClassName;
    UClass* DinoClass;
    TArray<unsigned char> DinoData;
    FString DinoName;
    FString DinoNameInMap;
    FString DinoStats[12];
    float DinoExperiencePoints;
    float Version;
    unsigned int DinoID1;
    unsigned int DinoID2;
};
 
struct FARKDinoData
{
    UClass* DinoClass;
    TArray<unsigned char> DinoData;
    FString DinoNameInMap;
    FString DinoName;
};
 
struct FDinoBaseLevelWeightEntry
{
    float EntryWeight;
    float BaseLevelMinRange;
    float BaseLevelMaxRange;
};
 
struct __declspec(align(8)) FClassRemappingWeight
{
    TSubclassOf<UObject> FromClass;
    TArray<TSubclassOf<UObject>> ToClasses;
    TArray<float> Weights;
    FName ActiveEvent;
    unsigned __int32 bExactMatch : 1;
};
 
struct FClassNameReplacement
{
    FString FromClassName;
    FString ToClassName;
};
 
struct FNPCDifficultyLevelRange
{
    TArray<float> EnemyLevelsMin;
    TArray<float> EnemyLevelsMax;
    TArray<float> GameDifficulties;
};
 
struct FAlivePlayerDataInfo
{
    FString PlayerName;
    FString PlayerSteamName;
    unsigned __int64 PlayerID;
    FString TribeName;
    unsigned __int64 TargetingTeamID;
};
 
struct FAdminPlayerDataInfo
{
    FString PlayerName;
    FString PlayerSteamName;
    FString SteamID;
    __int64 LinkedPlayerID;
    bool IsHost;
};
 
struct FNPCSpawnEntry
{
    FString AnEntryName;
    TArray<TSubclassOf<APrimalDinoCharacter>> NPCsToSpawn;
    TArray<FString> NPCsToSpawnStrings;
    TArray<FClassRemappingWeight> NPCRandomSpawnClassWeights;
    TArray<FVector> NPCsSpawnOffsets;
    TArray<float> NPCsToSpawnPercentageChance;
    TArray<float> NPCMinLevelOffset;
    TArray<float> NPCMaxLevelOffset;
    TArray<float> NPCMinLevelMultiplier;
    TArray<float> NPCMaxLevelMultiplier;
    unsigned __int32 bAddLevelOffsetBeforeMultiplier : 1;
    TArray<unsigned char> NPCOverrideLevel;
    FVector ExtentCheck;
    FVector GroupSpawnOffset;
    float EntryWeight;
    float ManualSpawnPointSpreadRadius;
    float WaterOnlySpawnMinimumWaterHeight;
    float MaximumWaterHeight;
    TArray<FNPCDifficultyLevelRange> NPCDifficultyLevelRanges;
    float LevelDifficultyTestOverride;
    float SpawnMinDistanceFromStructuresMultiplier;
    float SpawnMinDistanceFromPlayersMultiplier;
    float SpawnMinDistanceFromTamedDinosMultiplier;
    float RandGroupSpawnOffsetZMin;
    float RandGroupSpawnOffsetZMax;
};
 
struct FNPCSpawnLimit
{
    TSubclassOf<APrimalDinoCharacter> NPCClass;
    FString NPCClassString;
    float MaxPercentageOfDesiredNumToAllow;
    int CurrentNumberOfNPCTouching;
};
 
struct __declspec(align(8)) UNPCSpawnEntriesContainer : UObject
{
    TArray<FNPCSpawnEntry> NPCSpawnEntries;
    TArray<FNPCSpawnLimit> NPCSpawnLimits;
    float MaxDesiredNumEnemiesMultiplier;
};
 
struct FConfigCacheIni
{
};
 
struct FARKTributeDinoListing
{
    FString DinoName;
    FString DinoStats[12];
    float DinoExperiencePoints;
    UClass* DinoClass;
    unsigned int DinoID1;
    unsigned int DinoID2;
    unsigned int ExpirationTimeUTC;
};
 
struct FPrimalCharacterStatusStateDefinition
{
    TEnumAsByte<enum EPrimalCharacterStatusValue::Type> StatusValueType;
    int StatusValueThresholdIndex;
    UTexture2D* StatusStateIcon;
    FString StatusStateName;
    FString StatusStateDescription;
    FColor StatusStateNameColor;
    bool bUsed;
    bool bDisplayHUDMessage;
    FString HUDMessage;
    FColor HUDMessageColor;
    int BuffType;
};
 
struct __declspec(align(8)) FPrimalCharacterStatusValueDefinition
{
    UTexture2D* StatusValueIcon;
    FString StatusValueName;
    bool bLevelUpSetToMaxValue;
    bool bDisplayHideCurrentValue;
    bool bDisplayAsPercent;
};
 
struct FARKTributeData
{
    FGuid ID;
    TEnumAsByte<enum EPrimalARKTributeDataType::Type> DataType;
    TArray<unsigned char> DataBytes;
    FString DataClassName;
    FString DataTagName;
    FString Name;
    TArray<FString> DataStats;
    long double LastReceiveDataTime;
    unsigned int DataID1;
    unsigned int DataID2;
};
 
struct FArkTributePlayerDataListing
{
    unsigned __int64 PlayerDataID;
    FString PlayerName;
    FString PlayerStats[12];
    bool bWasAllowDPCUpload;
    FString UploadingServerMapName;
    bool bWithItems;
    unsigned int ItemCount;
    float Version;
    unsigned int ExpirationTimeUTC;
};
 
struct FArkTributePlayerData : FArkTributeEntity
{
    unsigned __int64 PlayerDataID;
    TArray<unsigned char> PlayerDataBytes;
    FString PlayerName;
    FString PlayerStats[12];
    FString UploadingServerMapName;
    bool bWasAllowDPCUpload;
    bool bWithItems;
    unsigned int ItemCount;
    bool bForServerTransfer;
    float Version;
};
 
struct USceneComponent : UActorComponent
{
    FTransform& ComponentToWorldField() { return *GetNativePointerField<FTransform*>(this, "USceneComponent.ComponentToWorld"); }
    TEnumAsByte<enum EComponentMobility::Type>& MobilityField() { return *GetNativePointerField<TEnumAsByte<enum EComponentMobility::Type>*>(this, "USceneComponent.Mobility"); }
    FBoxSphereBounds& BoundsField() { return *GetNativePointerField<FBoxSphereBounds*>(this, "USceneComponent.Bounds"); }
    USceneComponent* AttachParentField() { return *GetNativePointerField<USceneComponent**>(this, "USceneComponent.AttachParent"); }
    FName& AttachSocketNameField() { return *GetNativePointerField<FName*>(this, "USceneComponent.AttachSocketName"); }
    TArray<USceneComponent*> AttachChildrenField() { return *GetNativePointerField<TArray<USceneComponent*>*>(this, "USceneComponent.AttachChildren"); }
    FVector& RelativeLocationField() { return *GetNativePointerField<FVector*>(this, "USceneComponent.RelativeLocation"); }
    FRotator& RelativeRotationField() { return *GetNativePointerField<FRotator*>(this, "USceneComponent.RelativeRotation"); }
    TEnumAsByte<enum EDetailMode>& DetailModeField() { return *GetNativePointerField<TEnumAsByte<enum EDetailMode>*>(this, "USceneComponent.DetailMode"); }
    int& AttachmentChangedIncrementerField() { return *GetNativePointerField<int*>(this, "USceneComponent.AttachmentChangedIncrementer"); }
    bool& NetUpdateTransformField() { return *GetNativePointerField<bool*>(this, "USceneComponent.NetUpdateTransform"); }
    USceneComponent* NetOldAttachParentField() { return *GetNativePointerField<USceneComponent**>(this, "USceneComponent.NetOldAttachParent"); }
    FName& NetOldAttachSocketNameField() { return *GetNativePointerField<FName*>(this, "USceneComponent.NetOldAttachSocketName"); }
    FVector& RelativeScale3DField() { return *GetNativePointerField<FVector*>(this, "USceneComponent.RelativeScale3D"); }
    FVector& ComponentVelocityField() { return *GetNativePointerField<FVector*>(this, "USceneComponent.ComponentVelocity"); }
 
    // Bit fields
 
    BitFieldValue<bool, unsigned __int32> bRequiresCustomLocation() { return { this, "USceneComponent.bRequiresCustomLocation" }; }
    BitFieldValue<bool, unsigned __int32> bAbsoluteLocation() { return { this, "USceneComponent.bAbsoluteLocation" }; }
    BitFieldValue<bool, unsigned __int32> bAllowActorUpdateCallback() { return { this, "USceneComponent.bAllowActorUpdateCallback" }; }
    BitFieldValue<bool, unsigned __int32> bAbsoluteTranslation_DEPRECATED() { return { this, "USceneComponent.bAbsoluteTranslation_DEPRECATED" }; }
    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> bHiddenInGame() { return { this, "USceneComponent.bHiddenInGame" }; }
    BitFieldValue<bool, unsigned __int32> bAttachedSoundsForceHighPriority() { return { this, "USceneComponent.bAttachedSoundsForceHighPriority" }; }
    BitFieldValue<bool, unsigned __int32> bShouldUpdatePhysicsVolume() { return { this, "USceneComponent.bShouldUpdatePhysicsVolume" }; }
    BitFieldValue<bool, unsigned __int32> bUpdateChildOverlaps() { return { this, "USceneComponent.bUpdateChildOverlaps" }; }
    BitFieldValue<bool, unsigned __int32> bBoundsChangeTriggersStreamingDataRebuild() { return { this, "USceneComponent.bBoundsChangeTriggersStreamingDataRebuild" }; }
    BitFieldValue<bool, unsigned __int32> bUseAttachParentBound() { return { this, "USceneComponent.bUseAttachParentBound" }; }
    BitFieldValue<bool, unsigned __int32> bWorldToComponentUpdated() { return { this, "USceneComponent.bWorldToComponentUpdated" }; }
    BitFieldValue<bool, unsigned __int32> bClientSyncAlwaysUpdatePhysicsCollision() { return { this, "USceneComponent.bClientSyncAlwaysUpdatePhysicsCollision" }; }
    BitFieldValue<bool, unsigned __int32> bIgnoreParentTransformUpdate() { return { this, "USceneComponent.bIgnoreParentTransformUpdate" }; }
 
    // Functions
 
    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "USceneComponent.StaticClass"); }
    void OnChildAttached(USceneComponent* ChildComponent) { NativeCall<void, USceneComponent*>(this, "USceneComponent.OnChildAttached", ChildComponent); }
    FVector* GetCustomLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "USceneComponent.GetCustomLocation", result); }
 
    bool IsCollisionEnabled() { return NativeCall<bool>(this, "USceneComponent.IsCollisionEnabled"); }
    TArray<FName>* GetAllSocketNames(TArray<FName>* result) { return NativeCall<TArray<FName>*, TArray<FName>*>(this, "USceneComponent.GetAllSocketNames", result); }
    FVector* GetForwardVector(FVector* result) { return NativeCall<FVector*, FVector*>(this, "USceneComponent.GetForwardVector", result); }
    FTransform* CalcNewComponentToWorld(FTransform* result, FTransform* NewRelativeTransform, USceneComponent* Parent) { return NativeCall<FTransform*, FTransform*, FTransform*, USceneComponent*>(this, "USceneComponent.CalcNewComponentToWorld", result, NewRelativeTransform, Parent); }
    void UpdateComponentToWorldWithParent(USceneComponent* Parent, bool bSkipPhysicsMove, FQuat* RelativeRotationQuat) { NativeCall<void, USceneComponent*, bool, FQuat*>(this, "USceneComponent.UpdateComponentToWorldWithParent", Parent, bSkipPhysicsMove, RelativeRotationQuat); }
    void OnRegister() { NativeCall<void>(this, "USceneComponent.OnRegister"); }
    void UpdateComponentToWorld(bool bSkipPhysicsMove) { NativeCall<void, bool>(this, "USceneComponent.UpdateComponentToWorld", bSkipPhysicsMove); }
    void PropagateTransformUpdate(bool bTransformChanged, bool bSkipPhysicsMove) { NativeCall<void, bool, bool>(this, "USceneComponent.PropagateTransformUpdate", bTransformChanged, bSkipPhysicsMove); }
    void DestroyComponent() { NativeCall<void>(this, "USceneComponent.DestroyComponent"); }
    FBoxSphereBounds* CalcBounds(FBoxSphereBounds* result, FTransform* LocalToWorld) { return NativeCall<FBoxSphereBounds*, FBoxSphereBounds*, FTransform*>(this, "USceneComponent.CalcBounds", result, LocalToWorld); }
    void CalcBoundingCylinder(float* CylinderRadius, float* CylinderHalfHeight) { NativeCall<void, float*, float*>(this, "USceneComponent.CalcBoundingCylinder", CylinderRadius, CylinderHalfHeight); }
    void UpdateBounds() { NativeCall<void>(this, "USceneComponent.UpdateBounds"); }
    void SetRelativeLocationAndRotation(FVector NewLocation, FQuat* NewRotation, bool bSweep) { NativeCall<void, FVector, FQuat*, bool>(this, "USceneComponent.SetRelativeLocationAndRotation", NewLocation, NewRotation, bSweep); }
    void AddLocalOffset(FVector DeltaLocation, bool bSweep) { NativeCall<void, FVector, bool>(this, "USceneComponent.AddLocalOffset", DeltaLocation, bSweep); }
    void AddLocalRotation(FRotator DeltaRotation, bool bSweep) { NativeCall<void, FRotator, bool>(this, "USceneComponent.AddLocalRotation", DeltaRotation, bSweep); }
    void AddLocalTransform(FTransform* DeltaTransform, bool bSweep) { NativeCall<void, FTransform*, bool>(this, "USceneComponent.AddLocalTransform", DeltaTransform, bSweep); }
    void AddWorldTransform(FTransform* DeltaTransform, bool bSweep) { NativeCall<void, FTransform*, bool>(this, "USceneComponent.AddWorldTransform", DeltaTransform, bSweep); }
    void SetRelativeScale3D(FVector NewScale3D) { NativeCall<void, FVector>(this, "USceneComponent.SetRelativeScale3D", NewScale3D); }
    void ResetRelativeTransform() { NativeCall<void>(this, "USceneComponent.ResetRelativeTransform"); }
    void SetRelativeTransform(FTransform* NewTransform, bool bSweep) { NativeCall<void, FTransform*, bool>(this, "USceneComponent.SetRelativeTransform", NewTransform, bSweep); }
    FTransform* GetRelativeTransform(FTransform* result) { return NativeCall<FTransform*, FTransform*>(this, "USceneComponent.GetRelativeTransform", result); }
    void SetWorldLocation(FVector NewLocation, bool bSweep) { NativeCall<void, FVector, bool>(this, "USceneComponent.SetWorldLocation", NewLocation, bSweep); }
    void SetWorldRotation(FQuat* NewRotation, bool bSweep) { NativeCall<void, FQuat*, bool>(this, "USceneComponent.SetWorldRotation", NewRotation, bSweep); }
    void SetWorldScale3D(FVector NewScale) { NativeCall<void, FVector>(this, "USceneComponent.SetWorldScale3D", NewScale); }
    void SetWorldTransform(FTransform* NewTransform, bool bSweep) { NativeCall<void, FTransform*, bool>(this, "USceneComponent.SetWorldTransform", NewTransform, bSweep); }
    void SetWorldLocationAndRotation(FVector NewLocation, FRotator NewRotation, bool bSweep) { NativeCall<void, FVector, FRotator, bool>(this, "USceneComponent.SetWorldLocationAndRotation", NewLocation, NewRotation, bSweep); }
    void SetWorldLocationAndRotation(FVector NewLocation, FQuat* NewRotation, bool bSweep) { NativeCall<void, FVector, FQuat*, bool>(this, "USceneComponent.SetWorldLocationAndRotation", NewLocation, NewRotation, bSweep); }
    void SetWorldLocationAndRotationNoPhysics(FVector* NewLocation, FRotator* NewRotation) { NativeCall<void, FVector*, FRotator*>(this, "USceneComponent.SetWorldLocationAndRotationNoPhysics", NewLocation, NewRotation); }
    void SetAbsolute(bool bNewAbsoluteLocation, bool bNewAbsoluteRotation, bool bNewAbsoluteScale) { NativeCall<void, bool, bool, bool>(this, "USceneComponent.SetAbsolute", bNewAbsoluteLocation, bNewAbsoluteRotation, bNewAbsoluteScale); }
    FVector* GetRightVector(FVector* result) { return NativeCall<FVector*, FVector*>(this, "USceneComponent.GetRightVector", result); }
    FVector* GetUpVector(FVector* result) { return NativeCall<FVector*, FVector*>(this, "USceneComponent.GetUpVector", result); }
    USceneComponent* GetAttachParent() { return NativeCall<USceneComponent*>(this, "USceneComponent.GetAttachParent"); }
    void GetChildrenComponents(bool bIncludeAllDescendants, TArray<USceneComponent*>* Children) { NativeCall<void, bool, TArray<USceneComponent*>*>(this, "USceneComponent.GetChildrenComponents", bIncludeAllDescendants, Children); }
    void AppendDescendants(TArray<USceneComponent*>* Children) { NativeCall<void, TArray<USceneComponent*>*>(this, "USceneComponent.AppendDescendants", Children); }
    void AttachTo(USceneComponent* Parent, FName InSocketName, EAttachLocation::Type AttachType, bool bWeldSimulatedBodies) { NativeCall<void, USceneComponent*, FName, EAttachLocation::Type, bool>(this, "USceneComponent.AttachTo", Parent, InSocketName, AttachType, bWeldSimulatedBodies); }
    void DetachFromParent(bool bMaintainWorldPosition) { NativeCall<void, bool>(this, "USceneComponent.DetachFromParent", bMaintainWorldPosition); }
    FVector* GetMeshScaleMultiplier(FVector* result) { return NativeCall<FVector*, FVector*>(this, "USceneComponent.GetMeshScaleMultiplier", result); }
    FTransform* GetBaseToWorldTransform(FTransform* result) { return NativeCall<FTransform*, FTransform*>(this, "USceneComponent.GetBaseToWorldTransform", result); }
    AActor* GetAttachmentRootActor() { return NativeCall<AActor*>(this, "USceneComponent.GetAttachmentRootActor"); }
    void UpdateChildTransforms() { NativeCall<void>(this, "USceneComponent.UpdateChildTransforms"); }
    void Serialize(FArchive* Ar) { NativeCall<void, FArchive*>(this, "USceneComponent.Serialize", Ar); }
    void PostInterpChange(UProperty* PropertyThatChanged) { NativeCall<void, UProperty*>(this, "USceneComponent.PostInterpChange", PropertyThatChanged); }
    FTransform* GetSocketTransform(FTransform* result, FName SocketName, ERelativeTransformSpace TransformSpace) { return NativeCall<FTransform*, FTransform*, FName, ERelativeTransformSpace>(this, "USceneComponent.GetSocketTransform", result, SocketName, TransformSpace); }
    FVector* GetSocketLocation(FVector* result, FName SocketName) { return NativeCall<FVector*, FVector*, FName>(this, "USceneComponent.GetSocketLocation", result, SocketName); }
    FRotator* GetSocketRotation(FRotator* result, FName SocketName) { return NativeCall<FRotator*, FRotator*, FName>(this, "USceneComponent.GetSocketRotation", result, SocketName); }
    FQuat* GetSocketQuaternion(FQuat* result, FName SocketName) { return NativeCall<FQuat*, FQuat*, FName>(this, "USceneComponent.GetSocketQuaternion", result, SocketName); }
    FVector* GetComponentVelocity(FVector* result) { return NativeCall<FVector*, FVector*>(this, "USceneComponent.GetComponentVelocity", result); }
    void GetSocketWorldLocationAndRotation(FName InSocketName, FVector* OutLocation, FRotator* OutRotation) { NativeCall<void, FName, FVector*, FRotator*>(this, "USceneComponent.GetSocketWorldLocationAndRotation", InSocketName, OutLocation, OutRotation); }
    FCollisionResponseContainer* GetCollisionResponseToChannels() { return NativeCall<FCollisionResponseContainer*>(this, "USceneComponent.GetCollisionResponseToChannels"); }
    void SetMobility(EComponentMobility::Type NewMobility) { NativeCall<void, EComponentMobility::Type>(this, "USceneComponent.SetMobility", NewMobility); }
    bool IsAnySimulatingPhysics() { return NativeCall<bool>(this, "USceneComponent.IsAnySimulatingPhysics"); }
    void UpdatePhysicsVolume(bool bTriggerNotifiers) { NativeCall<void, bool>(this, "USceneComponent.UpdatePhysicsVolume", bTriggerNotifiers); }
    void BeginDestroy() { NativeCall<void>(this, "USceneComponent.BeginDestroy"); }
    bool InternalSetWorldLocationAndRotation(FVector NewLocation, FQuat* RotationQuat, bool bNoPhysics) { return NativeCall<bool, FVector, FQuat*, bool>(this, "USceneComponent.InternalSetWorldLocationAndRotation", NewLocation, RotationQuat, bNoPhysics); }
    bool MoveComponentImpl(FVector* Delta, FQuat* NewRotation, bool bSweep, FHitResult* OutHit, EMoveComponentFlags MoveFlags, bool bUpdateOverlaps) { return NativeCall<bool, FVector*, FQuat*, bool, FHitResult*, EMoveComponentFlags, bool>(this, "USceneComponent.MoveComponentImpl", Delta, NewRotation, bSweep, OutHit, MoveFlags, bUpdateOverlaps); }
    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 SetVisibility(bool bNewVisibility, bool bPropagateToChildren) { NativeCall<void, bool, bool>(this, "USceneComponent.SetVisibility", bNewVisibility, bPropagateToChildren); }
    void SetHiddenInGame(bool NewHiddenGame, bool bPropagateToChildren) { NativeCall<void, bool, bool>(this, "USceneComponent.SetHiddenInGame", NewHiddenGame, bPropagateToChildren); }
    void ApplyWorldOffset(FVector* InOffset, bool bWorldShift) { NativeCall<void, FVector*, bool>(this, "USceneComponent.ApplyWorldOffset", InOffset, bWorldShift); }
    FBoxSphereBounds* GetPlacementExtent(FBoxSphereBounds* result) { return NativeCall<FBoxSphereBounds*, FBoxSphereBounds*>(this, "USceneComponent.GetPlacementExtent", result); }
    void PreNetReceive() { NativeCall<void>(this, "USceneComponent.PreNetReceive"); }
    void PostNetReceive() { NativeCall<void>(this, "USceneComponent.PostNetReceive"); }
    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "USceneComponent.GetLifetimeReplicatedProps", OutLifetimeProps); }
    void StopSound(USoundBase* SoundToStop, float FadeOutTime) { NativeCall<void, USoundBase*, float>(this, "USceneComponent.StopSound", SoundToStop, FadeOutTime); }
    FVector* GetWorldLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "USceneComponent.GetWorldLocation", result); }
    static void StaticRegisterNativesUSceneComponent() { NativeCall<void>(nullptr, "USceneComponent.StaticRegisterNativesUSceneComponent"); }
};
 
struct UPrimitiveComponent : USceneComponent
{
    float& MinDrawDistanceField() { return *GetNativePointerField<float*>(this, "UPrimitiveComponent.MinDrawDistance"); }
    float& MassiveLODSizeOnScreenField() { return *GetNativePointerField<float*>(this, "UPrimitiveComponent.MassiveLODSizeOnScreen"); }
    float& LDMaxDrawDistanceField() { return *GetNativePointerField<float*>(this, "UPrimitiveComponent.LDMaxDrawDistance"); }
    float& CachedMaxDrawDistanceField() { return *GetNativePointerField<float*>(this, "UPrimitiveComponent.CachedMaxDrawDistance"); }
    TEnumAsByte<enum ESceneDepthPriorityGroup>& DepthPriorityGroupField() { return *GetNativePointerField<TEnumAsByte<enum ESceneDepthPriorityGroup>*>(this, "UPrimitiveComponent.DepthPriorityGroup"); }
    TEnumAsByte<enum ESceneDepthPriorityGroup>& ViewOwnerDepthPriorityGroupField() { return *GetNativePointerField<TEnumAsByte<enum ESceneDepthPriorityGroup>*>(this, "UPrimitiveComponent.ViewOwnerDepthPriorityGroup"); }
    int& CustomDepthStencilValueField() { return *GetNativePointerField<int*>(this, "UPrimitiveComponent.CustomDepthStencilValue"); }
    int& ObjectLayerField() { return *GetNativePointerField<int*>(this, "UPrimitiveComponent.ObjectLayer"); }
    TEnumAsByte<enum EIndirectLightingCacheQuality>& IndirectLightingCacheQualityField() { return *GetNativePointerField<TEnumAsByte<enum EIndirectLightingCacheQuality>*>(this, "UPrimitiveComponent.IndirectLightingCacheQuality"); }
    bool& bHasCachedStaticLightingField() { return *GetNativePointerField<bool*>(this, "UPrimitiveComponent.bHasCachedStaticLighting"); }
    bool& bStaticLightingBuildEnqueuedField() { return *GetNativePointerField<bool*>(this, "UPrimitiveComponent.bStaticLightingBuildEnqueued"); }
    int& TranslucencySortPriorityField() { return *GetNativePointerField<int*>(this, "UPrimitiveComponent.TranslucencySortPriority"); }
    int& VisibilityIdField() { return *GetNativePointerField<int*>(this, "UPrimitiveComponent.VisibilityId"); }
    float& LastPhysxSleepTimeField() { return *GetNativePointerField<float*>(this, "UPrimitiveComponent.LastPhysxSleepTime"); }
    unsigned int& GameThread_OverlapIncrementorField() { return *GetNativePointerField<unsigned int*>(this, "UPrimitiveComponent.GameThread_OverlapIncrementor"); }
    unsigned int& GameThread_OverlapIndexMaskField() { return *GetNativePointerField<unsigned int*>(this, "UPrimitiveComponent.GameThread_OverlapIndexMask"); }
    int& InternalOctreeMaskField() { return *GetNativePointerField<int*>(this, "UPrimitiveComponent.InternalOctreeMask"); }
    float& LpvBiasMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimitiveComponent.LpvBiasMultiplier"); }
    float& OverrideStepHeightField() { return *GetNativePointerField<float*>(this, "UPrimitiveComponent.OverrideStepHeight"); }
    FBodyInstance& BodyInstanceField() { return *GetNativePointerField<FBodyInstance*>(this, "UPrimitiveComponent.BodyInstance"); }
    float& LastCheckedAllCollideableDescendantsTimeField() { return *GetNativePointerField<float*>(this, "UPrimitiveComponent.LastCheckedAllCollideableDescendantsTime"); }
    float& BoundsScaleField() { return *GetNativePointerField<float*>(this, "UPrimitiveComponent.BoundsScale"); }
    long double& LastSubmitTimeField() { return *GetNativePointerField<long double*>(this, "UPrimitiveComponent.LastSubmitTime"); }
    long double& LastRenderTimeField() { return *GetNativePointerField<long double*>(this, "UPrimitiveComponent.LastRenderTime"); }
    long double& LastRenderTimeIgnoreShadowField() { return *GetNativePointerField<long double*>(this, "UPrimitiveComponent.LastRenderTimeIgnoreShadow"); }
    TEnumAsByte<enum ECanBeCharacterBase>& CanCharacterStepUpOnField() { return *GetNativePointerField<TEnumAsByte<enum ECanBeCharacterBase>*>(this, "UPrimitiveComponent.CanCharacterStepUpOn"); }
    TArray<TWeakObjectPtr<AActor>>& MoveIgnoreActorsField() { return *GetNativePointerField<TArray<TWeakObjectPtr<AActor>>*>(this, "UPrimitiveComponent.MoveIgnoreActors"); }
    FComponentBeginOverlapSignature& OnComponentBeginOverlapField() { return *GetNativePointerField<FComponentBeginOverlapSignature*>(this, "UPrimitiveComponent.OnComponentBeginOverlap"); }
    FComponentEndOverlapSignature& OnComponentEndOverlapField() { return *GetNativePointerField<FComponentEndOverlapSignature*>(this, "UPrimitiveComponent.OnComponentEndOverlap"); }
    FComponentBeginCursorOverSignature& OnBeginCursorOverField() { return *GetNativePointerField<FComponentBeginCursorOverSignature*>(this, "UPrimitiveComponent.OnBeginCursorOver"); }
    FComponentEndCursorOverSignature& OnEndCursorOverField() { return *GetNativePointerField<FComponentEndCursorOverSignature*>(this, "UPrimitiveComponent.OnEndCursorOver"); }
    FComponentOnClickedSignature& OnClickedField() { return *GetNativePointerField<FComponentOnClickedSignature*>(this, "UPrimitiveComponent.OnClicked"); }
    FComponentOnReleasedSignature& OnReleasedField() { return *GetNativePointerField<FComponentOnReleasedSignature*>(this, "UPrimitiveComponent.OnReleased"); }
    FComponentOnInputTouchBeginSignature& OnInputTouchBeginField() { return *GetNativePointerField<FComponentOnInputTouchBeginSignature*>(this, "UPrimitiveComponent.OnInputTouchBegin"); }
    FComponentOnInputTouchEndSignature& OnInputTouchEndField() { return *GetNativePointerField<FComponentOnInputTouchEndSignature*>(this, "UPrimitiveComponent.OnInputTouchEnd"); }
    FComponentBeginTouchOverSignature& OnInputTouchEnterField() { return *GetNativePointerField<FComponentBeginTouchOverSignature*>(this, "UPrimitiveComponent.OnInputTouchEnter"); }
    FComponentEndTouchOverSignature& OnInputTouchLeaveField() { return *GetNativePointerField<FComponentEndTouchOverSignature*>(this, "UPrimitiveComponent.OnInputTouchLeave"); }
    unsigned int& ProxyMeshIDField() { return *GetNativePointerField<unsigned int*>(this, "UPrimitiveComponent.ProxyMeshID"); }
    bool& bIsProxyMeshParentField() { return *GetNativePointerField<bool*>(this, "UPrimitiveComponent.bIsProxyMeshParent"); }
    bool& bHasActiveProxyMeshChildrenField() { return *GetNativePointerField<bool*>(this, "UPrimitiveComponent.bHasActiveProxyMeshChildren"); }
 
    // Bit fields
 
    BitFieldValue<bool, unsigned __int32> bUseAbsoluteMaxDrawDisatance() { return { this, "UPrimitiveComponent.bUseAbsoluteMaxDrawDisatance" }; }
    BitFieldValue<bool, unsigned __int32> bIncludeBoundsRadiusInDrawDistances() { return { this, "UPrimitiveComponent.bIncludeBoundsRadiusInDrawDistances" }; }
    BitFieldValue<bool, unsigned __int32> bExcludeFromLevelBounds() { return { this, "UPrimitiveComponent.bExcludeFromLevelBounds" }; }
    BitFieldValue<bool, unsigned __int32> bPreventCharacterBasing() { return { this, "UPrimitiveComponent.bPreventCharacterBasing" }; }
    BitFieldValue<bool, unsigned __int32> bAllowBasedCharacters() { return { this, "UPrimitiveComponent.bAllowBasedCharacters" }; }
    BitFieldValue<bool, unsigned __int32> bNoEncroachCheck_DEPRECATED() { return { this, "UPrimitiveComponent.bNoEncroachCheck_DEPRECATED" }; }
    BitFieldValue<bool, unsigned __int32> bDisableAllRigidBody_DEPRECATED() { return { this, "UPrimitiveComponent.bDisableAllRigidBody_DEPRECATED" }; }
    BitFieldValue<bool, unsigned __int32> bForceDynamicPhysics() { return { this, "UPrimitiveComponent.bForceDynamicPhysics" }; }
    BitFieldValue<bool, unsigned __int32> bPreventDamage() { return { this, "UPrimitiveComponent.bPreventDamage" }; }
    BitFieldValue<bool, unsigned __int32> bAlwaysCreatePhysicsState() { return { this, "UPrimitiveComponent.bAlwaysCreatePhysicsState" }; }
    BitFieldValue<bool, unsigned __int32> bGenerateOverlapEvents() { return { this, "UPrimitiveComponent.bGenerateOverlapEvents" }; }
    BitFieldValue<bool, unsigned __int32> bForceOverlapEvents() { return { this, "UPrimitiveComponent.bForceOverlapEvents" }; }
    BitFieldValue<bool, unsigned __int32> bMultiBodyOverlap() { return { this, "UPrimitiveComponent.bMultiBodyOverlap" }; }
    BitFieldValue<bool, unsigned __int32> bCheckAsyncSceneOnMove() { return { this, "UPrimitiveComponent.bCheckAsyncSceneOnMove" }; }
    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> bHasMotionBlurVelocityMeshes() { return { this, "UPrimitiveComponent.bHasMotionBlurVelocityMeshes" }; }
    BitFieldValue<bool, unsigned __int32> bRenderCustomDepth() { return { this, "UPrimitiveComponent.bRenderCustomDepth" }; }
    BitFieldValue<bool, unsigned __int32> bRenderInMainPass() { return { this, "UPrimitiveComponent.bRenderInMainPass" }; }
    BitFieldValue<bool, unsigned __int32> bIsInForeground() { return { this, "UPrimitiveComponent.bIsInForeground" }; }
    BitFieldValue<bool, unsigned __int32> HiddenGame_DEPRECATED() { return { this, "UPrimitiveComponent.HiddenGame_DEPRECATED" }; }
    BitFieldValue<bool, unsigned __int32> DrawInGame_DEPRECATED() { return { this, "UPrimitiveComponent.DrawInGame_DEPRECATED" }; }
    BitFieldValue<bool, unsigned __int32> bReceivesDecals() { return { this, "UPrimitiveComponent.bReceivesDecals" }; }
    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> bAffectDynamicIndirectLighting() { return { this, "UPrimitiveComponent.bAffectDynamicIndirectLighting" }; }
    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> bCastFarShadow() { return { this, "UPrimitiveComponent.bCastFarShadow" }; }
    BitFieldValue<bool, unsigned __int32> bCastInsetShadow() { return { this, "UPrimitiveComponent.bCastInsetShadow" }; }
    BitFieldValue<bool, unsigned __int32> bCastHiddenShadow() { return { this, "UPrimitiveComponent.bCastHiddenShadow" }; }
    BitFieldValue<bool, unsigned __int32> bCastShadowAsTwoSided() { return { this, "UPrimitiveComponent.bCastShadowAsTwoSided" }; }
    BitFieldValue<bool, unsigned __int32> bLightAsIfStatic() { return { this, "UPrimitiveComponent.bLightAsIfStatic" }; }
    BitFieldValue<bool, unsigned __int32> bLightAttachmentsAsGroup() { return { this, "UPrimitiveComponent.bLightAttachmentsAsGroup" }; }
    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> bIgnoreRadialImpulse() { return { this, "UPrimitiveComponent.bIgnoreRadialImpulse" }; }
    BitFieldValue<bool, unsigned __int32> bIgnoreRadialForce() { return { this, "UPrimitiveComponent.bIgnoreRadialForce" }; }
    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> bIgnoredByCharacterEncroachment() { return { this, "UPrimitiveComponent.bIgnoredByCharacterEncroachment" }; }
    BitFieldValue<bool, unsigned __int32> bMovableUseDynamicDrawDistance() { return { this, "UPrimitiveComponent.bMovableUseDynamicDrawDistance" }; }
    BitFieldValue<bool, unsigned __int32> bCanEverAffectNavigation() { return { this, "UPrimitiveComponent.bCanEverAffectNavigation" }; }
    BitFieldValue<bool, unsigned __int32> bNavigationRelevant() { return { this, "UPrimitiveComponent.bNavigationRelevant" }; }
    BitFieldValue<bool, unsigned __int32> bCachedAllCollideableDescendantsRelative() { return { this, "UPrimitiveComponent.bCachedAllCollideableDescendantsRelative" }; }
 
    // Functions
 
    bool CanBeBaseForCharacter(APawn* Pawn) { return NativeCall<bool, APawn*>(this, "UPrimitiveComponent.CanBeBaseForCharacter", Pawn); }
    bool AreSymmetricRotations(FQuat* A, FQuat* B, FVector* Scale3D) { return NativeCall<bool, FQuat*, FQuat*, FVector*>(this, "UPrimitiveComponent.AreSymmetricRotations", A, B, Scale3D); }
    char GetStaticDepthPriorityGroup() { return NativeCall<char>(this, "UPrimitiveComponent.GetStaticDepthPriorityGroup"); }
    bool HasValidSettingsForStaticLighting() { return NativeCall<bool>(this, "UPrimitiveComponent.HasValidSettingsForStaticLighting"); }
    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "UPrimitiveComponent.GetPrivateStaticClass"); }
    void GetLightAndShadowMapMemoryUsage(int* OutNum, int* OutMax) { NativeCall<void, int*, int*>(this, "UPrimitiveComponent.GetLightAndShadowMapMemoryUsage", OutNum, OutMax); }
    void DestroyRenderState_Concurrent() { NativeCall<void>(this, "UPrimitiveComponent.DestroyRenderState_Concurrent"); }
    void FinishDestroy() { NativeCall<void>(this, "UPrimitiveComponent.FinishDestroy"); }
    void InvalidateLightingCacheDetailed(bool bInvalidateBuildEnqueuedLighting, bool bTranslationOnly) { NativeCall<void, bool, bool>(this, "UPrimitiveComponent.InvalidateLightingCacheDetailed", bInvalidateBuildEnqueuedLighting, bTranslationOnly); }
    bool IsEditorOnly() { return NativeCall<bool>(this, "UPrimitiveComponent.IsEditorOnly"); }
    void RegisterComponentTickFunctions(bool bRegister, bool bSaveAndRestoreComponentTickState) { NativeCall<void, bool, bool>(this, "UPrimitiveComponent.RegisterComponentTickFunctions", bRegister, bSaveAndRestoreComponentTickState); }
    void CreateRenderState_Concurrent() { NativeCall<void>(this, "UPrimitiveComponent.CreateRenderState_Concurrent"); }
    void SendRenderTransform_Concurrent() { NativeCall<void>(this, "UPrimitiveComponent.SendRenderTransform_Concurrent"); }
    void OnRegister() { NativeCall<void>(this, "UPrimitiveComponent.OnRegister"); }
    void OnUnregister() { NativeCall<void>(this, "UPrimitiveComponent.OnUnregister"); }
    void OnAttachmentChanged() { NativeCall<void>(this, "UPrimitiveComponent.OnAttachmentChanged"); }
    void CreatePhysicsState() { NativeCall<void>(this, "UPrimitiveComponent.CreatePhysicsState"); }
    void OnUpdateTransform(bool bSkipPhysicsMove) { NativeCall<void, bool>(this, "UPrimitiveComponent.OnUpdateTransform", bSkipPhysicsMove); }
    void Serialize(FArchive* Ar) { NativeCall<void, FArchive*>(this, "UPrimitiveComponent.Serialize", Ar); }
    void PostLoad() { NativeCall<void>(this, "UPrimitiveComponent.PostLoad"); }
    void PostDuplicate(bool bDuplicateForPIE) { NativeCall<void, bool>(this, "UPrimitiveComponent.PostDuplicate", bDuplicateForPIE); }
    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", bNewOwnerNoSee); }
    void SetOnlyOwnerSee(bool bNewOnlyOwnerSee) { NativeCall<void, bool>(this, "UPrimitiveComponent.SetOnlyOwnerSee", 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 SetCastShadow(bool NewCastShadow) { NativeCall<void, bool>(this, "UPrimitiveComponent.SetCastShadow", NewCastShadow); }
    void SetCullDistance(float NewCullDistance) { NativeCall<void, float>(this, "UPrimitiveComponent.SetCullDistance", NewCullDistance); }
    void SetAbsoluteMaxDrawScale(bool bInValue) { NativeCall<void, bool>(this, "UPrimitiveComponent.SetAbsoluteMaxDrawScale", bInValue); }
    bool IsWorldGeometry() { return NativeCall<bool>(this, "UPrimitiveComponent.IsWorldGeometry"); }
    ECollisionChannel GetCollisionObjectType() { return NativeCall<ECollisionChannel>(this, "UPrimitiveComponent.GetCollisionObjectType"); }
    void InitSweepCollisionParams(FCollisionQueryParams* OutParams, FCollisionResponseParams* OutResponseParam) { NativeCall<void, FCollisionQueryParams*, FCollisionResponseParams*>(this, "UPrimitiveComponent.InitSweepCollisionParams", OutParams, OutResponseParam); }
    bool MoveComponentImpl(FVector* Delta, FQuat* NewRotationQuat, bool bSweep, FHitResult* OutHit, EMoveComponentFlags MoveFlags, bool bUpdateOverlaps) { return NativeCall<bool, FVector*, FQuat*, bool, FHitResult*, EMoveComponentFlags, bool>(this, "UPrimitiveComponent.MoveComponentImpl", Delta, NewRotationQuat, bSweep, OutHit, MoveFlags, bUpdateOverlaps); }
    void DispatchBlockingHit(AActor* Owner, FHitResult* BlockingHit) { NativeCall<void, AActor*, FHitResult*>(this, "UPrimitiveComponent.DispatchBlockingHit", Owner, BlockingHit); }
    bool IsNavigationRelevant() { return NativeCall<bool>(this, "UPrimitiveComponent.IsNavigationRelevant"); }
    FBox* GetNavigationBounds(FBox* result) { return NativeCall<FBox*, FBox*>(this, "UPrimitiveComponent.GetNavigationBounds", result); }
    void SetCanEverAffectNavigation(bool bRelevant) { NativeCall<void, bool>(this, "UPrimitiveComponent.SetCanEverAffectNavigation", bRelevant); }
    bool LineTraceComponent(FHitResult* OutHit, FVector Start, FVector End, FCollisionQueryParams* Params) { return NativeCall<bool, FHitResult*, FVector, FVector, FCollisionQueryParams*>(this, "UPrimitiveComponent.LineTraceComponent", OutHit, Start, End, Params); }
    bool ComponentOverlapComponentImpl(UPrimitiveComponent* PrimComp, FVector Pos, FQuat* Quat, FCollisionQueryParams* Params) { return NativeCall<bool, UPrimitiveComponent*, FVector, FQuat*, FCollisionQueryParams*>(this, "UPrimitiveComponent.ComponentOverlapComponentImpl", PrimComp, Pos, Quat, Params); }
    bool IsOverlappingActor(AActor* Other) { return NativeCall<bool, AActor*>(this, "UPrimitiveComponent.IsOverlappingActor", Other); }
    void GetOverlappingActors(TArray<AActor*>* OutOverlappingActors, UClass* ClassFilter) { NativeCall<void, TArray<AActor*>*, UClass*>(this, "UPrimitiveComponent.GetOverlappingActors", OutOverlappingActors, ClassFilter); }
    void GetOverlappingComponents(TArray<UPrimitiveComponent*>* OutOverlappingComponents) { NativeCall<void, TArray<UPrimitiveComponent*>*>(this, "UPrimitiveComponent.GetOverlappingComponents", OutOverlappingComponents); }
    bool AreAllCollideableDescendantsRelative(bool bAllowCachedValue) { return NativeCall<bool, bool>(this, "UPrimitiveComponent.AreAllCollideableDescendantsRelative", bAllowCachedValue); }
    void IgnoreActorWhenMoving(AActor* Actor, bool bShouldIgnore) { NativeCall<void, AActor*, bool>(this, "UPrimitiveComponent.IgnoreActorWhenMoving", Actor, bShouldIgnore); }
    TArray<TWeakObjectPtr<AActor>>* GetMoveIgnoreActors() { return NativeCall<TArray<TWeakObjectPtr<AActor>>*>(this, "UPrimitiveComponent.GetMoveIgnoreActors"); }
    void UpdatePhysicsVolume(bool bTriggerNotifiers) { NativeCall<void, bool>(this, "UPrimitiveComponent.UpdatePhysicsVolume", bTriggerNotifiers); }
    static void DispatchMouseOverEvents(UPrimitiveComponent* CurrentComponent, UPrimitiveComponent* NewComponent) { NativeCall<void, UPrimitiveComponent*, UPrimitiveComponent*>(nullptr, "UPrimitiveComponent.DispatchMouseOverEvents", CurrentComponent, NewComponent); }
    static void DispatchTouchOverEvents(ETouchIndex::Type FingerIndex, UPrimitiveComponent* CurrentComponent, UPrimitiveComponent* NewComponent) { NativeCall<void, ETouchIndex::Type, UPrimitiveComponent*, UPrimitiveComponent*>(nullptr, "UPrimitiveComponent.DispatchTouchOverEvents", FingerIndex, CurrentComponent, NewComponent); }
    void DispatchOnClicked() { NativeCall<void>(this, "UPrimitiveComponent.DispatchOnClicked"); }
    void DispatchOnReleased() { NativeCall<void>(this, "UPrimitiveComponent.DispatchOnReleased"); }
    void DispatchOnInputTouchBegin(ETouchIndex::Type FingerIndex) { NativeCall<void, ETouchIndex::Type>(this, "UPrimitiveComponent.DispatchOnInputTouchBegin", FingerIndex); }
    void DispatchOnInputTouchEnd(ETouchIndex::Type FingerIndex) { NativeCall<void, ETouchIndex::Type>(this, "UPrimitiveComponent.DispatchOnInputTouchEnd", FingerIndex); }
    void SetRenderCustomDepth(bool bValue) { NativeCall<void, bool>(this, "UPrimitiveComponent.SetRenderCustomDepth", bValue); }
    void SetCollisionResponseSet(FCollisionResponseSet* Col) { NativeCall<void, FCollisionResponseSet*>(this, "UPrimitiveComponent.SetCollisionResponseSet", Col); }
    void SetCustomDepthStencilValue(int Value) { NativeCall<void, int>(this, "UPrimitiveComponent.SetCustomDepthStencilValue", Value); }
    bool CanCharacterStepUp(APawn* Pawn) { return NativeCall<bool, APawn*>(this, "UPrimitiveComponent.CanCharacterStepUp", Pawn); }
    bool CanEditSimulatePhysics() { return NativeCall<bool>(this, "UPrimitiveComponent.CanEditSimulatePhysics"); }
    void SetSimulatePhysics(bool bSimulate) { NativeCall<void, bool>(this, "UPrimitiveComponent.SetSimulatePhysics", bSimulate); }
    void AddImpulse(FVector Impulse, FName BoneName, bool bVelChange) { NativeCall<void, FVector, FName, bool>(this, "UPrimitiveComponent.AddImpulse", Impulse, BoneName, bVelChange); }
    void AddImpulseAtLocation(FVector Impulse, FVector Location, FName BoneName) { NativeCall<void, FVector, FVector, FName>(this, "UPrimitiveComponent.AddImpulseAtLocation", Impulse, Location, BoneName); }
    void AddRadialImpulse(FVector Origin, float Radius, float Strength, ERadialImpulseFalloff Falloff, bool bVelChange) { NativeCall<void, FVector, float, float, ERadialImpulseFalloff, bool>(this, "UPrimitiveComponent.AddRadialImpulse", Origin, Radius, Strength, Falloff, bVelChange); }
    void AddForce(FVector Force, FName BoneName) { NativeCall<void, FVector, FName>(this, "UPrimitiveComponent.AddForce", Force, BoneName); }
    void AddForceAtLocation(FVector Force, FVector Location, FName BoneName) { NativeCall<void, FVector, FVector, FName>(this, "UPrimitiveComponent.AddForceAtLocation", Force, Location, BoneName); }
    void AddRadialForce(FVector Origin, float Radius, float Strength, ERadialImpulseFalloff Falloff) { NativeCall<void, FVector, float, float, ERadialImpulseFalloff>(this, "UPrimitiveComponent.AddRadialForce", Origin, Radius, Strength, Falloff); }
    void SetPhysicsLinearVelocity(FVector NewVel, bool bAddToCurrent, FName BoneName) { NativeCall<void, FVector, bool, FName>(this, "UPrimitiveComponent.SetPhysicsLinearVelocity", NewVel, bAddToCurrent, BoneName); }
    FVector* GetPhysicsLinearVelocity(FVector* result, FName BoneName) { return NativeCall<FVector*, FVector*, FName>(this, "UPrimitiveComponent.GetPhysicsLinearVelocity", result, BoneName); }
    void SetAllPhysicsLinearVelocity(FVector NewVel, bool bAddToCurrent) { NativeCall<void, FVector, bool>(this, "UPrimitiveComponent.SetAllPhysicsLinearVelocity", NewVel, bAddToCurrent); }
    void SetPhysicsAngularVelocity(FVector NewAngVel, bool bAddToCurrent, FName BoneName) { NativeCall<void, FVector, bool, FName>(this, "UPrimitiveComponent.SetPhysicsAngularVelocity", NewAngVel, bAddToCurrent, BoneName); }
    FVector* GetPhysicsAngularVelocity(FVector* result, FName BoneName) { return NativeCall<FVector*, FVector*, FName>(this, "UPrimitiveComponent.GetPhysicsAngularVelocity", result, BoneName); }
    void SetAllPhysicsAngularVelocity(FVector* NewAngVel, bool bAddToCurrent) { NativeCall<void, FVector*, bool>(this, "UPrimitiveComponent.SetAllPhysicsAngularVelocity", NewAngVel, bAddToCurrent); }
    void SetAllPhysicsPosition(FVector NewPos) { NativeCall<void, FVector>(this, "UPrimitiveComponent.SetAllPhysicsPosition", NewPos); }
    void SetAllPhysicsRotation(FRotator NewRot) { NativeCall<void, FRotator>(this, "UPrimitiveComponent.SetAllPhysicsRotation", NewRot); }
    void WakeRigidBody(FName BoneName) { NativeCall<void, FName>(this, "UPrimitiveComponent.WakeRigidBody", BoneName); }
    void WakeAllRigidBodies() { NativeCall<void>(this, "UPrimitiveComponent.WakeAllRigidBodies"); }
    void SetEnableGravity(bool bGravityEnabled) { NativeCall<void, bool>(this, "UPrimitiveComponent.SetEnableGravity", bGravityEnabled); }
    bool IsGravityEnabled() { return NativeCall<bool>(this, "UPrimitiveComponent.IsGravityEnabled"); }
    void SetLinearDamping(float InDamping) { NativeCall<void, float>(this, "UPrimitiveComponent.SetLinearDamping", InDamping); }
    float GetLinearDamping() { return NativeCall<float>(this, "UPrimitiveComponent.GetLinearDamping"); }
    void SetAngularDamping(float InDamping) { NativeCall<void, float>(this, "UPrimitiveComponent.SetAngularDamping", InDamping); }
    float GetAngularDamping() { return NativeCall<float>(this, "UPrimitiveComponent.GetAngularDamping"); }
    float GetMass() { return NativeCall<float>(this, "UPrimitiveComponent.GetMass"); }
    float CalculateMass(FName __formal) { return NativeCall<float, FName>(this, "UPrimitiveComponent.CalculateMass", __formal); }
    void PutRigidBodyToSleep(FName BoneName) { NativeCall<void, FName>(this, "UPrimitiveComponent.PutRigidBodyToSleep", BoneName); }
    void PutAllRigidBodiesToSleep() { NativeCall<void>(this, "UPrimitiveComponent.PutAllRigidBodiesToSleep"); }
    bool RigidBodyIsAwake(FName BoneName) { return NativeCall<bool, FName>(this, "UPrimitiveComponent.RigidBodyIsAwake", BoneName); }
    bool IsAnyRigidBodyAwake() { return NativeCall<bool>(this, "UPrimitiveComponent.IsAnyRigidBodyAwake"); }
    void SetNotifyRigidBodyCollision(bool bNewNotifyRigidBodyCollision) { NativeCall<void, bool>(this, "UPrimitiveComponent.SetNotifyRigidBodyCollision", bNewNotifyRigidBodyCollision); }
    void SetPhysMaterialOverride(UPhysicalMaterial* NewPhysMaterial) { NativeCall<void, UPhysicalMaterial*>(this, "UPrimitiveComponent.SetPhysMaterialOverride", NewPhysMaterial); }
    void SyncComponentToRBPhysics() { NativeCall<void>(this, "UPrimitiveComponent.SyncComponentToRBPhysics"); }
    void GetWeldedBodies(TArray<FBodyInstance*>* OutWeldedBodies, TArray<FName>* OutLabels) { NativeCall<void, TArray<FBodyInstance*>*, TArray<FName>*>(this, "UPrimitiveComponent.GetWeldedBodies", OutWeldedBodies, OutLabels); }
    void WeldTo(USceneComponent* InParent, FName InSocketName) { NativeCall<void, USceneComponent*, FName>(this, "UPrimitiveComponent.WeldTo", InParent, InSocketName); }
    void UnWeldFromParent() { NativeCall<void>(this, "UPrimitiveComponent.UnWeldFromParent"); }
    FBodyInstance* GetBodyInstance(FName BoneName, bool bGetWelded) { return NativeCall<FBodyInstance*, FName, bool>(this, "UPrimitiveComponent.GetBodyInstance", BoneName, bGetWelded); }
    float GetDistanceToCollision(FVector* Point, FVector* ClosestPointOnCollision) { return NativeCall<float, FVector*, FVector*>(this, "UPrimitiveComponent.GetDistanceToCollision", Point, ClosestPointOnCollision); }
    bool IsSimulatingPhysics(FName BoneName) { return NativeCall<bool, FName>(this, "UPrimitiveComponent.IsSimulatingPhysics", BoneName); }
    FVector* GetComponentVelocity(FVector* result) { return NativeCall<FVector*, FVector*>(this, "UPrimitiveComponent.GetComponentVelocity", result); }
    void SetCollisionObjectType(ECollisionChannel Channel) { NativeCall<void, ECollisionChannel>(this, "UPrimitiveComponent.SetCollisionObjectType", Channel); }
    void SetCollisionResponseToChannel(ECollisionChannel Channel, ECollisionResponse NewResponse) { NativeCall<void, ECollisionChannel, ECollisionResponse>(this, "UPrimitiveComponent.SetCollisionResponseToChannel", Channel, NewResponse); }
    void SetCollisionResponseToAllChannels(ECollisionResponse NewResponse) { NativeCall<void, ECollisionResponse>(this, "UPrimitiveComponent.SetCollisionResponseToAllChannels", NewResponse); }
    void SetCollisionEnabled(ECollisionEnabled::Type NewType) { NativeCall<void, ECollisionEnabled::Type>(this, "UPrimitiveComponent.SetCollisionEnabled", NewType); }
    void SetCollisionProfileName(FName InCollisionProfileName) { NativeCall<void, FName>(this, "UPrimitiveComponent.SetCollisionProfileName", InCollisionProfileName); }
    FName* GetCollisionProfileName(FName* result) { return NativeCall<FName*, FName*>(this, "UPrimitiveComponent.GetCollisionProfileName", result); }
    void OnActorEnableCollisionChanged() { NativeCall<void>(this, "UPrimitiveComponent.OnActorEnableCollisionChanged"); }
    void OnComponentCollisionSettingsChanged() { NativeCall<void>(this, "UPrimitiveComponent.OnComponentCollisionSettingsChanged"); }
    bool K2_LineTraceComponent(FVector TraceStart, FVector TraceEnd, bool bTraceComplex, bool bShowTrace, FVector* HitLocation, FVector* HitNormal, FName* BoneName) { return NativeCall<bool, FVector, FVector, bool, bool, FVector*, FVector*, FName*>(this, "UPrimitiveComponent.K2_LineTraceComponent", TraceStart, TraceEnd, bTraceComplex, bShowTrace, HitLocation, HitNormal, BoneName); }
    ECollisionEnabled::Type GetCollisionEnabled() { return NativeCall<ECollisionEnabled::Type>(this, "UPrimitiveComponent.GetCollisionEnabled"); }
    ECollisionResponse GetCollisionResponseToChannel(ECollisionChannel Channel) { return NativeCall<ECollisionResponse, ECollisionChannel>(this, "UPrimitiveComponent.GetCollisionResponseToChannel", Channel); }
    void UpdatePhysicsToRBChannels() { NativeCall<void>(this, "UPrimitiveComponent.UpdatePhysicsToRBChannels"); }
    void SetInternalOctreeMask(int InOctreeMask, bool bReregisterWithTree) { NativeCall<void, int, bool>(this, "UPrimitiveComponent.SetInternalOctreeMask", InOctreeMask, bReregisterWithTree); }
    static void StaticRegisterNativesUPrimitiveComponent() { NativeCall<void>(nullptr, "UPrimitiveComponent.StaticRegisterNativesUPrimitiveComponent"); }
};
 
struct UShapeComponent : UPrimitiveComponent
{
    UMaterialInterface* ShapeMaterialField() { return *GetNativePointerField<UMaterialInterface**>(this, "UShapeComponent.ShapeMaterial"); }
 
    // Bit fields
 
    BitFieldValue<bool, unsigned __int32> bDrawOnlyIfSelected() { return { this, "UShapeComponent.bDrawOnlyIfSelected" }; }
    BitFieldValue<bool, unsigned __int32> bShouldCollideWhenPlacing() { return { this, "UShapeComponent.bShouldCollideWhenPlacing" }; }
 
    // Functions
 
    bool ShouldCollideWhenPlacing() { return NativeCall<bool>(this, "UShapeComponent.ShouldCollideWhenPlacing"); }
};
 
struct USphereComponent : UShapeComponent
{
 
    // Functions
 
    FBoxSphereBounds* CalcBounds(FBoxSphereBounds* result, FTransform* LocalToWorld) { return NativeCall<FBoxSphereBounds*, FBoxSphereBounds*, FTransform*>(this, "USphereComponent.CalcBounds", result, LocalToWorld); }
    void CalcBoundingCylinder(float* CylinderRadius, float* CylinderHalfHeight) { NativeCall<void, float*, float*>(this, "USphereComponent.CalcBoundingCylinder", CylinderRadius, CylinderHalfHeight); }
    void UpdateBodySetup() { NativeCall<void>(this, "USphereComponent.UpdateBodySetup"); }
    void SetSphereRadius(float InSphereRadius, bool bUpdateOverlaps) { NativeCall<void, float, bool>(this, "USphereComponent.SetSphereRadius", InSphereRadius, bUpdateOverlaps); }
    bool IsZeroExtent() { return NativeCall<bool>(this, "USphereComponent.IsZeroExtent"); }
    bool AreSymmetricRotations(FQuat* A, FQuat* B, FVector* Scale3D) { return NativeCall<bool, FQuat*, FQuat*, FVector*>(this, "USphereComponent.AreSymmetricRotations", A, B, Scale3D); }
    static void StaticRegisterNativesUSphereComponent() { NativeCall<void>(nullptr, "USphereComponent.StaticRegisterNativesUSphereComponent"); }
};
 
struct AActor : UObject
{
    float& CustomTimeDilationField() { return *GetNativePointerField<float*>(this, "AActor.CustomTimeDilation"); }
    float& ClientReplicationSendNowThresholdField() { return *GetNativePointerField<float*>(this, "AActor.ClientReplicationSendNowThreshold"); }
    bool& bForceAllowNetMulticastField() { return *GetNativePointerField<bool*>(this, "AActor.bForceAllowNetMulticast"); }
    TEnumAsByte<enum ENetRole>& RemoteRoleField() { return *GetNativePointerField<TEnumAsByte<enum ENetRole>*>(this, "AActor.RemoteRole"); }
    AActor* OwnerField() { return *GetNativePointerField<AActor**>(this, "AActor.Owner"); }
    long double& LastReplicatedMovementField() { return *GetNativePointerField<long double*>(this, "AActor.LastReplicatedMovement"); }
    int& LastFrameForceNetUpdateField() { return *GetNativePointerField<int*>(this, "AActor.LastFrameForceNetUpdate"); }
    TEnumAsByte<enum ENetRole>& RoleField() { return *GetNativePointerField<TEnumAsByte<enum ENetRole>*>(this, "AActor.Role"); }
    TEnumAsByte<enum ENetDormancy>& NetDormancyField() { return *GetNativePointerField<TEnumAsByte<enum ENetDormancy>*>(this, "AActor.NetDormancy"); }
    TArray<TWeakObjectPtr<UActorComponent>>& ReplicatedComponentsField() { return *GetNativePointerField<TArray<TWeakObjectPtr<UActorComponent>>*>(this, "AActor.ReplicatedComponents"); }
    TWeakObjectPtr<USoundBase>& LastPostProcessVolumeSoundField() { return *GetNativePointerField<TWeakObjectPtr<USoundBase>*>(this, "AActor.LastPostProcessVolumeSound"); }
    int& DefaultStasisComponentOctreeFlagsField() { return *GetNativePointerField<int*>(this, "AActor.DefaultStasisComponentOctreeFlags"); }
    UPrimitiveComponent* StasisCheckComponentField() { return *GetNativePointerField<UPrimitiveComponent**>(this, "AActor.StasisCheckComponent"); }
    TArray<AActor*> NetworkSpatializationChildrenField() { return *GetNativePointerField<TArray<AActor*>*>(this, "AActor.NetworkSpatializationChildren"); }
    AActor* NetworkSpatializationParentField() { return *GetNativePointerField<AActor**>(this, "AActor.NetworkSpatializationParent"); }
    float& NetworkAndStasisRangeMultiplierField() { return *GetNativePointerField<float*>(this, "AActor.NetworkAndStasisRangeMultiplier"); }
    long double& UnstasisLastInRangeTimeField() { return *GetNativePointerField<long double*>(this, "AActor.UnstasisLastInRangeTime"); }
    long double& LastPreReplicationTimeField() { return *GetNativePointerField<long double*>(this, "AActor.LastPreReplicationTime"); }
    long double& LastEnterStasisTimeField() { return *GetNativePointerField<long double*>(this, "AActor.LastEnterStasisTime"); }
    long double& LastExitStasisTimeField() { return *GetNativePointerField<long double*>(this, "AActor.LastExitStasisTime"); }
    FName& CustomTagField() { return *GetNativePointerField<FName*>(this, "AActor.CustomTag"); }
    int& CustomDataField() { return *GetNativePointerField<int*>(this, "AActor.CustomData"); }
    float& ReplicationIntervalMultiplierField() { return *GetNativePointerField<float*>(this, "AActor.ReplicationIntervalMultiplier"); }
    int& ForceImmediateReplicationFrameField() { return *GetNativePointerField<int*>(this, "AActor.ForceImmediateReplicationFrame"); }
    char& StasisSetIndexField() { return *GetNativePointerField<char*>(this, "AActor.StasisSetIndex"); }
    char& RandomStartByteField() { return *GetNativePointerField<char*>(this, "AActor.RandomStartByte"); }
    unsigned __int64& LastFrameUnStasisField() { return *GetNativePointerField<unsigned __int64*>(this, "AActor.LastFrameUnStasis"); }
    volatile int& LastUnstasisFrameCounterField() { return *GetNativePointerField<volatile int*>(this, "AActor.LastUnstasisFrameCounter"); }
    TArray<TWeakObjectPtr<UActorComponent>>& StasisUnRegisteredComponentsField() { return *GetNativePointerField<TArray<TWeakObjectPtr<UActorComponent>>*>(this, "AActor.StasisUnRegisteredComponents"); }
    float& NetCullDistanceSquaredField() { return *GetNativePointerField<float*>(this, "AActor.NetCullDistanceSquared"); }
    float& NetCullDistanceSquaredDormantField() { return *GetNativePointerField<float*>(this, "AActor.NetCullDistanceSquaredDormant"); }
    int& NetTagField() { return *GetNativePointerField<int*>(this, "AActor.NetTag"); }
    long double& NetUpdateTimeField() { return *GetNativePointerField<long double*>(this, "AActor.NetUpdateTime"); }
    float& NetUpdateFrequencyField() { return *GetNativePointerField<float*>(this, "AActor.NetUpdateFrequency"); }
    float& NetPriorityField() { return *GetNativePointerField<float*>(this, "AActor.NetPriority"); }
    long double& LastNetUpdateTimeField() { return *GetNativePointerField<long double*>(this, "AActor.LastNetUpdateTime"); }
    FName& NetDriverNameField() { return *GetNativePointerField<FName*>(this, "AActor.NetDriverName"); }
    int& TargetingTeamField() { return *GetNativePointerField<int*>(this, "AActor.TargetingTeam"); }
    float& OverrideStasisComponentRadiusField() { return *GetNativePointerField<float*>(this, "AActor.OverrideStasisComponentRadius"); }
    APawn* InstigatorField() { return *GetNativePointerField<APawn**>(this, "AActor.Instigator"); }
    long double& CreationTimeField() { return *GetNativePointerField<long double*>(this, "AActor.CreationTime"); }
    long double& OriginalCreationTimeField() { return *GetNativePointerField<long double*>(this, "AActor.OriginalCreationTime"); }
    TArray<AActor*> ChildrenField() { return *GetNativePointerField<TArray<AActor*>*>(this, "AActor.Children"); }
    unsigned int& AnimUpdateRateShiftTagField() { return *GetNativePointerField<unsigned int*>(this, "AActor.AnimUpdateRateShiftTag"); }
    unsigned int& AnimUpdateRateFrameCountField() { return *GetNativePointerField<unsigned int*>(this, "AActor.AnimUpdateRateFrameCount"); }
    USceneComponent* RootComponentField() { return *GetNativePointerField<USceneComponent**>(this, "AActor.RootComponent"); }
    TArray<AMatineeActor*> ControllingMatineeActorsField() { return *GetNativePointerField<TArray<AMatineeActor*>*>(this, "AActor.ControllingMatineeActors"); }
    float& InitialLifeSpanField() { return *GetNativePointerField<float*>(this, "AActor.InitialLifeSpan"); }
    TArray<FName>& LayersField() { return *GetNativePointerField<TArray<FName>*>(this, "AActor.Layers"); }
    TWeakObjectPtr<AActor>& ParentComponentActorField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "AActor.ParentComponentActor"); }
    long double& LastRenderTimeField() { return *GetNativePointerField<long double*>(this, "AActor.LastRenderTime"); }
    long double& LastRenderTimeIgnoreShadowField() { return *GetNativePointerField<long double*>(this, "AActor.LastRenderTimeIgnoreShadow"); }
    TArray<FName>& TagsField() { return *GetNativePointerField<TArray<FName>*>(this, "AActor.Tags"); }
    unsigned __int64& HiddenEditorViewsField() { return *GetNativePointerField<unsigned __int64*>(this, "AActor.HiddenEditorViews"); }
    FTargetingTeamChanged& OnTargetingTeamChangedField() { return *GetNativePointerField<FTargetingTeamChanged*>(this, "AActor.OnTargetingTeamChanged"); }
    FVector& DefaultActorLocationField() { return *GetNativePointerField<FVector*>(this, "AActor.DefaultActorLocation"); }
    FGuid& UniqueGuidIdField() { return *GetNativePointerField<FGuid*>(this, "AActor.UniqueGuidId"); }
    float& ForceMaximumReplicationRateUntilTimeField() { return *GetNativePointerField<float*>(this, "AActor.ForceMaximumReplicationRateUntilTime"); }
    long double& LastActorForceReplicationTimeField() { return *GetNativePointerField<long double*>(this, "AActor.LastActorForceReplicationTime"); }
    TArray<UActorComponent*> OwnedComponentsField() { return *GetNativePointerField<TArray<UActorComponent*>*>(this, "AActor.OwnedComponents"); }
    TArray<UActorComponent*> SerializedComponentsField() { return *GetNativePointerField<TArray<UActorComponent*>*>(this, "AActor.SerializedComponents"); }
    int& LastFrameCalculcatedNetworkRangeMultiplierField() { return *GetNativePointerField<int*>(this, "AActor.LastFrameCalculcatedNetworkRangeMultiplier"); }
 
    // Bit fields
 
    BitFieldValue<bool, unsigned __int32> bHidden() { return { this, "AActor.bHidden" }; }
    BitFieldValue<bool, unsigned __int32> bNetTemporary() { return { this, "AActor.bNetTemporary" }; }
    BitFieldValue<bool, unsigned __int32> bIsMapActor() { return { this, "AActor.bIsMapActor" }; }
    BitFieldValue<bool, unsigned __int32> bHasHighVolumeRPCs() { return { this, "AActor.bHasHighVolumeRPCs" }; }
    BitFieldValue<bool, unsigned __int32> bNetStartup() { return { this, "AActor.bNetStartup" }; }
    BitFieldValue<bool, unsigned __int32> bPreventCharacterBasing() { return { this, "AActor.bPreventCharacterBasing" }; }
    BitFieldValue<bool, unsigned __int32> bPreventCharacterBasingAllowSteppingUp() { return { this, "AActor.bPreventCharacterBasingAllowSteppingUp" }; }
    BitFieldValue<bool, unsigned __int32> bOnlyRelevantToOwner() { return { this, "AActor.bOnlyRelevantToOwner" }; }
    BitFieldValue<bool, unsigned __int32> bAlwaysRelevant() { return { this, "AActor.bAlwaysRelevant" }; }
    BitFieldValue<bool, unsigned __int32> bForceHiddenReplication() { return { this, "AActor.bForceHiddenReplication" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPChangedActorTeam() { return { this, "AActor.bUseBPChangedActorTeam" }; }
    BitFieldValue<bool, unsigned __int32> bHasExecutedActorConstruction() { return { this, "AActor.bHasExecutedActorConstruction" }; }
    BitFieldValue<bool, unsigned __int32> bEverSetTimer() { return { this, "AActor.bEverSetTimer" }; }
    BitFieldValue<bool, unsigned __int32> bIgnoredByCharacterEncroachment() { return { this, "AActor.bIgnoredByCharacterEncroachment" }; }
    BitFieldValue<bool, unsigned __int32> bClimbable() { return { this, "AActor.bClimbable" }; }
    BitFieldValue<bool, unsigned __int32> bAttachmentReplicationUseNetworkParent() { return { this, "AActor.bAttachmentReplicationUseNetworkParent" }; }
    BitFieldValue<bool, unsigned __int32> bUnstreamComponentsUseEndOverlap() { return { this, "AActor.bUnstreamComponentsUseEndOverlap" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOverrideUILocation() { return { this, "AActor.bUseBPOverrideUILocation" }; }
    BitFieldValue<bool, unsigned __int32> bForceBasedActorsOutOfFastTick() { return { this, "AActor.bForceBasedActorsOutOfFastTick" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPGetShowDebugAnimationComponents() { return { this, "AActor.bUseBPGetShowDebugAnimationComponents" }; }
    BitFieldValue<bool, unsigned __int32> bWantsServerThrottledTick() { return { this, "AActor.bWantsServerThrottledTick" }; }
    BitFieldValue<bool, unsigned __int32> bAddedServerThrottledTick() { return { this, "AActor.bAddedServerThrottledTick" }; }
    BitFieldValue<bool, unsigned __int32> bWantsPerformanceThrottledTick() { return { this, "AActor.bWantsPerformanceThrottledTick" }; }
    BitFieldValue<bool, unsigned __int32> bAddedPerformanceThrottledTick() { return { this, "AActor.bAddedPerformanceThrottledTick" }; }
    BitFieldValue<bool, unsigned __int32> bForceInfiniteDrawDistance() { return { this, "AActor.bForceInfiniteDrawDistance" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPCheckForErrors() { return { this, "AActor.bUseBPCheckForErrors" }; }
    BitFieldValue<bool, unsigned __int32> bPreventRegularForceNetUpdate() { return { this, "AActor.bPreventRegularForceNetUpdate" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOverrideTargetingLocation() { return { this, "AActor.bUseBPOverrideTargetingLocation" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPGetHUDDrawLocationOffset() { return { this, "AActor.bUseBPGetHUDDrawLocationOffset" }; }
    BitFieldValue<bool, unsigned __int32> bPreventNPCSpawnFloor() { return { this, "AActor.bPreventNPCSpawnFloor" }; }
    BitFieldValue<bool, unsigned __int32> bNetCritical() { return { this, "AActor.bNetCritical" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPCustomIsRelevantForClient() { return { this, "AActor.bUseBPCustomIsRelevantForClient" }; }
    BitFieldValue<bool, unsigned __int32> bReplicateInstigator() { return { this, "AActor.bReplicateInstigator" }; }
    BitFieldValue<bool, unsigned __int32> bSuppressDestroyedEvent() { return { this, "AActor.bSuppressDestroyedEvent" }; }
    BitFieldValue<bool, unsigned __int32> bUseOnlyPointForLevelBounds() { return { this, "AActor.bUseOnlyPointForLevelBounds" }; }
    BitFieldValue<bool, unsigned __int32> bReplicateMovement() { return { this, "AActor.bReplicateMovement" }; }
    BitFieldValue<bool, unsigned __int32> bTearOff() { return { this, "AActor.bTearOff" }; }
    BitFieldValue<bool, unsigned __int32> bExchangedRoles() { return { this, "AActor.bExchangedRoles" }; }
    BitFieldValue<bool, unsigned __int32> bStasised() { return { this, "AActor.bStasised" }; }
    BitFieldValue<bool, unsigned __int32> bPendingUnstasis() { return { this, "AActor.bPendingUnstasis" }; }
    BitFieldValue<bool, unsigned __int32> bPendingNetUpdate() { return { this, "AActor.bPendingNetUpdate" }; }
    BitFieldValue<bool, unsigned __int32> bNetLoadOnClient() { return { this, "AActor.bNetLoadOnClient" }; }
    BitFieldValue<bool, unsigned __int32> bNetUseOwnerRelevancy() { return { this, "AActor.bNetUseOwnerRelevancy" }; }
    BitFieldValue<bool, unsigned __int32> bNetUseClientRelevancy() { return { this, "AActor.bNetUseClientRelevancy" }; }
    BitFieldValue<bool, unsigned __int32> bDoNotCook() { return { this, "AActor.bDoNotCook" }; }
    BitFieldValue<bool, unsigned __int32> bHibernateChange() { return { this, "AActor.bHibernateChange" }; }
    BitFieldValue<bool, unsigned __int32> bBlockInput() { return { this, "AActor.bBlockInput" }; }
    BitFieldValue<bool, unsigned __int32> bAutoStasis() { return { this, "AActor.bAutoStasis" }; }
    BitFieldValue<bool, unsigned __int32> bBlueprintMultiUseEntries() { return { this, "AActor.bBlueprintMultiUseEntries" }; }
    BitFieldValue<bool, unsigned __int32> bEnableMultiUse() { return { this, "AActor.bEnableMultiUse" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPGetMultiUseCenterText() { return { this, "AActor.bUseBPGetMultiUseCenterText" }; }
    BitFieldValue<bool, unsigned __int32> bPreventSaving() { return { this, "AActor.bPreventSaving" }; }
    BitFieldValue<bool, unsigned __int32> bMultiUseCenterHUD() { return { this, "AActor.bMultiUseCenterHUD" }; }
    BitFieldValue<bool, unsigned __int32> bOnlyInitialReplication() { return { this, "AActor.bOnlyInitialReplication" }; }
    BitFieldValue<bool, unsigned __int32> bUseAttachmentReplication() { return { this, "AActor.bUseAttachmentReplication" }; }
    BitFieldValue<bool, unsigned __int32> bUseNetworkSpatialization() { return { this, "AActor.bUseNetworkSpatialization" }; }
    BitFieldValue<bool, unsigned __int32> bNetworkSpatializationForceRelevancyCheck() { return { this, "AActor.bNetworkSpatializationForceRelevancyCheck" }; }
    BitFieldValue<bool, unsigned __int32> bReplicates() { return { this, "AActor.bReplicates" }; }
    BitFieldValue<bool, unsigned __int32> bRunningUserConstructionScript() { return { this, "AActor.bRunningUserConstructionScript" }; }
    BitFieldValue<bool, unsigned __int32> bHasFinishedSpawning() { return { this, "AActor.bHasFinishedSpawning" }; }
    BitFieldValue<bool, unsigned __int32> bDeferredBeginPlay() { return { this, "AActor.bDeferredBeginPlay" }; }
    BitFieldValue<bool, unsigned __int32> bHasReplicatedProperties() { return { this, "AActor.bHasReplicatedProperties" }; }
    BitFieldValue<bool, unsigned __int32> bActorEnableCollision() { return { this, "AActor.bActorEnableCollision" }; }
    BitFieldValue<bool, unsigned __int32> bAutoDestroyWhenFinished() { return { this, "AActor.bAutoDestroyWhenFinished" }; }
    BitFieldValue<bool, unsigned __int32> bCanBeDamaged() { return { this, "AActor.bCanBeDamaged" }; }
    BitFieldValue<bool, unsigned __int32> bPendingKillPending() { return { this, "AActor.bPendingKillPending" }; }
    BitFieldValue<bool, unsigned __int32> bCollideWhenPlacing() { return { this, "AActor.bCollideWhenPlacing" }; }
    BitFieldValue<bool, unsigned __int32> bPreventOnDedicatedServer() { return { this, "AActor.bPreventOnDedicatedServer" }; }
    BitFieldValue<bool, unsigned __int32> bNetMulticasting() { return { this, "AActor.bNetMulticasting" }; }
    BitFieldValue<bool, unsigned __int32> bNetConnectionDidInitialSort() { return { this, "AActor.bNetConnectionDidInitialSort" }; }
    BitFieldValue<bool, unsigned __int32> bDormantNetMulticastForceFullReplication() { return { this, "AActor.bDormantNetMulticastForceFullReplication" }; }
    BitFieldValue<bool, unsigned __int32> bDoOverrideHiddenShadow() { return { this, "AActor.bDoOverrideHiddenShadow" }; }
    BitFieldValue<bool, unsigned __int32> bOverrideHiddenShadowValue() { return { this, "AActor.bOverrideHiddenShadowValue" }; }
    BitFieldValue<bool, unsigned __int32> bAllowReceiveTickEventOnDedicatedServer() { return { this, "AActor.bAllowReceiveTickEventOnDedicatedServer" }; }
    BitFieldValue<bool, unsigned __int32> bLoadedFromSaveGame() { return { this, "AActor.bLoadedFromSaveGame" }; }
    BitFieldValue<bool, unsigned __int32> bPreventLevelBoundsRelevant() { return { this, "AActor.bPreventLevelBoundsRelevant" }; }
    BitFieldValue<bool, unsigned __int32> bForceReplicateDormantChildrenWithoutSpatialRelevancy() { return { this, "AActor.bForceReplicateDormantChildrenWithoutSpatialRelevancy" }; }
    BitFieldValue<bool, unsigned __int32> bFindCameraComponentWhenViewTarget() { return { this, "AActor.bFindCameraComponentWhenViewTarget" }; }
    BitFieldValue<bool, unsigned __int32> bBPPreInitializeComponents() { return { this, "AActor.bBPPreInitializeComponents" }; }
    BitFieldValue<bool, unsigned __int32> bBPPostInitializeComponents() { return { this, "AActor.bBPPostInitializeComponents" }; }
    BitFieldValue<bool, unsigned __int32> bForceNetworkSpatialization() { return { this, "AActor.bForceNetworkSpatialization" }; }
    BitFieldValue<bool, unsigned __int32> bStasisComponentRadiusForceDistanceCheck() { return { this, "AActor.bStasisComponentRadiusForceDistanceCheck" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPInventoryItemUsed() { return { this, "AActor.bUseBPInventoryItemUsed" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPInventoryItemDropped() { return { this, "AActor.bUseBPInventoryItemDropped" }; }
    BitFieldValue<bool, unsigned __int32> bBPInventoryItemUsedHandlesDurability() { return { this, "AActor.bBPInventoryItemUsedHandlesDurability" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPForceAllowsInventoryUse() { return { this, "AActor.bUseBPForceAllowsInventoryUse" }; }
    BitFieldValue<bool, unsigned __int32> bAlwaysCreatePhysicsState() { return { this, "AActor.bAlwaysCreatePhysicsState" }; }
    BitFieldValue<bool, unsigned __int32> bReplicateRotationHighQuality() { return { this, "AActor.bReplicateRotationHighQuality" }; }
    BitFieldValue<bool, unsigned __int32> bReplicateVelocityHighQuality() { return { this, "AActor.bReplicateVelocityHighQuality" }; }
    BitFieldValue<bool, unsigned __int32> bOnlyReplicateOnNetForcedUpdate() { return { this, "AActor.bOnlyReplicateOnNetForcedUpdate" }; }
    BitFieldValue<bool, unsigned __int32> bActorInitialized() { return { this, "AActor.bActorInitialized" }; }
    BitFieldValue<bool, unsigned __int32> bActorSeamlessTraveled() { return { this, "AActor.bActorSeamlessTraveled" }; }
    BitFieldValue<bool, unsigned __int32> bIgnoresOriginShifting() { return { this, "AActor.bIgnoresOriginShifting" }; }
    BitFieldValue<bool, unsigned __int32> bReplicateHidden() { return { this, "AActor.bReplicateHidden" }; }
    BitFieldValue<bool, unsigned __int32> bPreventActorStasis() { return { this, "AActor.bPreventActorStasis" }; }
 
    // Functions
 
    FVector* GetTargetPathfindingLocation(FVector* result, AActor* RequestedBy) { return NativeCall<FVector*, FVector*, AActor*>(this, "AActor.GetTargetPathfindingLocation", result, RequestedBy); }
    bool IsLevelBoundsRelevant() { return NativeCall<bool>(this, "AActor.IsLevelBoundsRelevant"); }
    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "AActor.GetPrivateStaticClass"); }
    bool IsPendingKillPending() { return NativeCall<bool>(this, "AActor.IsPendingKillPending"); }
    bool IsOwnedBy(AActor* TestOwner) { return NativeCall<bool, AActor*>(this, "AActor.IsOwnedBy", TestOwner); }
    void SetRemoteRoleForBackwardsCompat(ENetRole InRemoteRole) { NativeCall<void, ENetRole>(this, "AActor.SetRemoteRoleForBackwardsCompat", InRemoteRole); }
    static const wchar_t* StaticConfigName() { return NativeCall<const wchar_t*>(nullptr, "AActor.StaticConfigName"); }
    FString* GetHumanReadableName(FString* result) { return NativeCall<FString*, FString*>(this, "AActor.GetHumanReadableName", result); }
    UGameInstance* GetOwner() { return NativeCall<UGameInstance*>(this, "AActor.GetOwner"); }
    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"); }
    UWorld* GetWorld() { return NativeCall<UWorld*>(this, "AActor.GetWorld"); }
    bool IsInGameplayWorld() { return NativeCall<bool>(this, "AActor.IsInGameplayWorld"); }
    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(FVector* DestLocation, FRotator* DestRotation, bool bIsATest, bool bNoCheck) { return NativeCall<bool, FVector*, FRotator*, bool, bool>(this, "AActor.TeleportTo", DestLocation, DestRotation, bIsATest, bNoCheck); }
    bool SimpleTeleportTo(FVector* DestLocation, FRotator* DestRotation) { return NativeCall<bool, FVector*, FRotator*>(this, "AActor.SimpleTeleportTo", DestLocation, DestRotation); }
    void AddTickPrerequisiteActor(AActor* PrerequisiteActor) { NativeCall<void, AActor*>(this, "AActor.AddTickPrerequisiteActor", PrerequisiteActor); }
    void AddTickPrerequisiteComponent(UActorComponent* PrerequisiteComponent) { NativeCall<void, UActorComponent*>(this, "AActor.AddTickPrerequisiteComponent", PrerequisiteComponent); }
    void RemoveTickPrerequisiteActor(AActor* PrerequisiteActor) { NativeCall<void, AActor*>(this, "AActor.RemoveTickPrerequisiteActor", PrerequisiteActor); }
    void RemoveTickPrerequisiteComponent(UActorComponent* PrerequisiteComponent) { NativeCall<void, UActorComponent*>(this, "AActor.RemoveTickPrerequisiteComponent", PrerequisiteComponent); }
    void BeginDestroy() { NativeCall<void>(this, "AActor.BeginDestroy"); }
    bool IsReadyForFinishDestroy() { return NativeCall<bool>(this, "AActor.IsReadyForFinishDestroy"); }
    void PostLoad() { NativeCall<void>(this, "AActor.PostLoad"); }
    void PostLoadSubobjects(FObjectInstancingGraph* OuterInstanceGraph) { NativeCall<void, FObjectInstancingGraph*>(this, "AActor.PostLoadSubobjects", OuterInstanceGraph); }
    void ProcessEvent(UFunction* Function, void* Parameters) { NativeCall<void, UFunction*, void*>(this, "AActor.ProcessEvent", Function, Parameters); }
    void RegisterActorTickFunctions(bool bRegister, bool bSaveAndRestoreTickState) { NativeCall<void, bool, bool>(this, "AActor.RegisterActorTickFunctions", bRegister, bSaveAndRestoreTickState); }
    void RegisterAllActorTickFunctions(bool bRegister, bool bDoComponents, bool bSaveAndRestoreTickState) { NativeCall<void, bool, bool, bool>(this, "AActor.RegisterAllActorTickFunctions", bRegister, bDoComponents, bSaveAndRestoreTickState); }
    void SetActorTickEnabled(bool bEnabled) { NativeCall<void, bool>(this, "AActor.SetActorTickEnabled", bEnabled); }
    bool Rename(const wchar_t* InName, UObject* NewOuter, unsigned int Flags) { return NativeCall<bool, const wchar_t*, UObject*, unsigned int>(this, "AActor.Rename", InName, NewOuter, Flags); }
    UNetConnection* GetNetConnection() { return NativeCall<UNetConnection*>(this, "AActor.GetNetConnection"); }
    UPlayer* GetNetOwningPlayer() { return NativeCall<UPlayer*>(this, "AActor.GetNetOwningPlayer"); }
    void Tick(float DeltaSeconds) { NativeCall<void, float>(this, "AActor.Tick", DeltaSeconds); }
    void GetComponentsBoundingCylinder(float* OutCollisionRadius, float* OutCollisionHalfHeight, bool bNonColliding) { NativeCall<void, float*, float*, bool>(this, "AActor.GetComponentsBoundingCylinder", OutCollisionRadius, OutCollisionHalfHeight, bNonColliding); }
    void GetSimpleCollisionCylinder(float* CollisionRadius, float* CollisionHalfHeight) { NativeCall<void, float*, float*>(this, "AActor.GetSimpleCollisionCylinder", CollisionRadius, CollisionHalfHeight); }
    float GetApproachRadius() { return NativeCall<float>(this, "AActor.GetApproachRadius"); }
    bool IsRootComponentCollisionRegistered() { return NativeCall<bool>(this, "AActor.IsRootComponentCollisionRegistered"); }
    bool IsAttachedTo(AActor* Other) { return NativeCall<bool, AActor*>(this, "AActor.IsAttachedTo", Other); }
    bool IsBasedOnActor(AActor* Other) { return NativeCall<bool, AActor*>(this, "AActor.IsBasedOnActor", Other); }
    bool Modify(bool bAlwaysMarkDirty) { return NativeCall<bool, bool>(this, "AActor.Modify", bAlwaysMarkDirty); }
    FBox* GetComponentsBoundingBox(FBox* result, bool bNonColliding) { return NativeCall<FBox*, FBox*, bool>(this, "AActor.GetComponentsBoundingBox", result, bNonColliding); }
    FBox* GetComponentsBoundingBoxForLevelBounds(FBox* result) { return NativeCall<FBox*, FBox*>(this, "AActor.GetComponentsBoundingBoxForLevelBounds", result); }
    bool CheckStillInWorld() { return NativeCall<bool>(this, "AActor.CheckStillInWorld"); }
    void UpdateOverlaps(bool bDoNotifies) { NativeCall<void, bool>(this, "AActor.UpdateOverlaps", bDoNotifies); }
    void GetOverlappingActors(TArray<AActor*>* OverlappingActors, UClass* ClassFilter) { NativeCall<void, TArray<AActor*>*, UClass*>(this, "AActor.GetOverlappingActors", OverlappingActors, ClassFilter); }
    void GetOverlappingComponents(TArray<UPrimitiveComponent*>* OutOverlappingComponents) { NativeCall<void, TArray<UPrimitiveComponent*>*>(this, "AActor.GetOverlappingComponents", OutOverlappingComponents); }
    long double GetLastRenderTime(bool ignoreShadow) { return NativeCall<long double, bool>(this, "AActor.GetLastRenderTime", ignoreShadow); }
    void SetOwner(AActor* NewOwner) { NativeCall<void, AActor*>(this, "AActor.SetOwner", NewOwner); }
    bool HasNetOwner() { return NativeCall<bool>(this, "AActor.HasNetOwner"); }
    void AttachRootComponentTo(USceneComponent* InParent, FName InSocketName, EAttachLocation::Type AttachLocationType, bool bWeldSimulatedBodies) { NativeCall<void, USceneComponent*, FName, EAttachLocation::Type, bool>(this, "AActor.AttachRootComponentTo", InParent, InSocketName, AttachLocationType, bWeldSimulatedBodies); }
    void OnRep_AttachmentReplication() { NativeCall<void>(this, "AActor.OnRep_AttachmentReplication"); }
    void AttachRootComponentToActor(AActor* InParentActor, FName InSocketName, EAttachLocation::Type AttachLocationType, bool bWeldSimulatedBodies) { NativeCall<void, AActor*, FName, EAttachLocation::Type, bool>(this, "AActor.AttachRootComponentToActor", InParentActor, InSocketName, AttachLocationType, bWeldSimulatedBodies); }
    void DetachRootComponentFromParent(bool bMaintainWorldPosition) { NativeCall<void, bool>(this, "AActor.DetachRootComponentFromParent", bMaintainWorldPosition); }
    void DetachSceneComponentsFromParent(USceneComponent* InParentComponent, bool bMaintainWorldPosition) { NativeCall<void, USceneComponent*, bool>(this, "AActor.DetachSceneComponentsFromParent", InParentComponent, bMaintainWorldPosition); }
    AActor* GetAttachParentActor() { return NativeCall<AActor*>(this, "AActor.GetAttachParentActor"); }
    FName* GetAttachParentSocketName(FName* result) { return NativeCall<FName*, FName*>(this, "AActor.GetAttachParentSocketName", result); }
    void GetAttachedActors(TArray<AActor*>* OutActors) { NativeCall<void, TArray<AActor*>*>(this, "AActor.GetAttachedActors", OutActors); }
    bool ActorHasTag(FName Tag) { return NativeCall<bool, FName>(this, "AActor.ActorHasTag", Tag); }
    bool IsMatineeControlled() { return NativeCall<bool>(this, "AActor.IsMatineeControlled"); }
    bool IsRootComponentStatic() { return NativeCall<bool>(this, "AActor.IsRootComponentStatic"); }
    bool IsRootComponentStationary() { return NativeCall<bool>(this, "AActor.IsRootComponentStationary"); }
    bool IsRootComponentMovable() { return NativeCall<bool>(this, "AActor.IsRootComponentMovable"); }
    bool IsRelevancyOwnerFor(AActor* ReplicatedActor, AActor* ActorOwner, AActor* ConnectionActor) { return NativeCall<bool, AActor*, AActor*, AActor*>(this, "AActor.IsRelevancyOwnerFor", ReplicatedActor, ActorOwner, ConnectionActor); }
    void FlushNetDormancy() { NativeCall<void>(this, "AActor.FlushNetDormancy"); }
    void PrestreamTextures(float Seconds, bool bEnableStreaming, int CinematicTextureGroups) { NativeCall<void, float, bool, int>(this, "AActor.PrestreamTextures", Seconds, bEnableStreaming, CinematicTextureGroups); }
    void EndPlay(EEndPlayReason::Type EndPlayReason) { NativeCall<void, EEndPlayReason::Type>(this, "AActor.EndPlay", EndPlayReason); }
    FTransform* ActorToWorld(FTransform* result) { return NativeCall<FTransform*, FTransform*>(this, "AActor.ActorToWorld", result); }
    FTransform* GetTransform(FTransform* result) { return NativeCall<FTransform*, FTransform*>(this, "AActor.GetTransform", result); }
    void ClearNetworkSpatializationParent() { NativeCall<void>(this, "AActor.ClearNetworkSpatializationParent"); }
    void SetNetworkSpatializationParent(AActor* NewParent) { NativeCall<void, AActor*>(this, "AActor.SetNetworkSpatializationParent", NewParent); }
    void Destroyed() { NativeCall<void>(this, "AActor.Destroyed"); }
    void FellOutOfWorld(UDamageType* dmgType) { NativeCall<void, UDamageType*>(this, "AActor.FellOutOfWorld", dmgType); }
    void MakeNoise(float Loudness, APawn* NoiseInstigator, FVector NoiseLocation) { NativeCall<void, float, APawn*, FVector>(this, "AActor.MakeNoise", Loudness, NoiseInstigator, NoiseLocation); }
    static void MakeNoiseImpl(AActor* NoiseMaker, float Loudness, APawn* NoiseInstigator, FVector* NoiseLocation) { NativeCall<void, AActor*, float, APawn*, FVector*>(nullptr, "AActor.MakeNoiseImpl", NoiseMaker, Loudness, NoiseInstigator, NoiseLocation); }
    float TakeDamage(float DamageAmount, FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { return NativeCall<float, float, FDamageEvent*, AController*, AActor*>(this, "AActor.TakeDamage", DamageAmount, DamageEvent, EventInstigator, DamageCauser); }
    float InternalTakeRadialDamage(float Damage, FRadialDamageEvent* RadialDamageEvent, AController* EventInstigator, AActor* DamageCauser) { return NativeCall<float, float, FRadialDamageEvent*, AController*, AActor*>(this, "AActor.InternalTakeRadialDamage", Damage, RadialDamageEvent, EventInstigator, DamageCauser); }
    void DispatchBlockingHit(UPrimitiveComponent* MyComp, UPrimitiveComponent* OtherComp, bool bSelfMoved, FHitResult* Hit) { NativeCall<void, UPrimitiveComponent*, UPrimitiveComponent*, bool, FHitResult*>(this, "AActor.DispatchBlockingHit", MyComp, OtherComp, bSelfMoved, Hit); }
    void OutsideWorldBounds() { NativeCall<void>(this, "AActor.OutsideWorldBounds"); }
    void BecomeViewTarget(APlayerController* PC) { NativeCall<void, APlayerController*>(this, "AActor.BecomeViewTarget", PC); }
    void EndViewTarget(APlayerController* PC) { NativeCall<void, APlayerController*>(this, "AActor.EndViewTarget", PC); }
    AController* GetInstigatorController() { return NativeCall<AController*>(this, "AActor.GetInstigatorController"); }
    void CalcCamera(float DeltaTime, FMinimalViewInfo* OutResult) { NativeCall<void, float, FMinimalViewInfo*>(this, "AActor.CalcCamera", DeltaTime, OutResult); }
    void ForceNetRelevant() { NativeCall<void>(this, "AActor.ForceNetRelevant"); }
    void GetActorEyesViewPoint(FVector* OutLocation, FRotator* OutRotation) { NativeCall<void, FVector*, FRotator*>(this, "AActor.GetActorEyesViewPoint", OutLocation, OutRotation); }
    FVector* GetActorViewDirection(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AActor.GetActorViewDirection", result); }
    void InventoryItemUsed(UObject* InventoryItemObject) { NativeCall<void, UObject*>(this, "AActor.InventoryItemUsed", InventoryItemObject); }
    void InventoryItemDropped(UObject* InventoryItemObject) { NativeCall<void, UObject*>(this, "AActor.InventoryItemDropped", InventoryItemObject); }
    bool ForceAllowsInventoryUse(UObject* InventoryItemObject) { return NativeCall<bool, UObject*>(this, "AActor.ForceAllowsInventoryUse", InventoryItemObject); }
    ECollisionResponse GetComponentsCollisionResponseToChannel(ECollisionChannel Channel) { return NativeCall<ECollisionResponse, ECollisionChannel>(this, "AActor.GetComponentsCollisionResponseToChannel", Channel); }
    void AddOwnedComponent(UActorComponent* Component) { NativeCall<void, UActorComponent*>(this, "AActor.AddOwnedComponent", Component); }
    void RemoveOwnedComponent(UActorComponent* Component) { NativeCall<void, UActorComponent*>(this, "AActor.RemoveOwnedComponent", Component); }
    UActorComponent* GetComponentByClass(TSubclassOf<UActorComponent> ComponentClass) { return NativeCall<UActorComponent*, TSubclassOf<UActorComponent>>(this, "AActor.GetComponentByClass", ComponentClass); }
    FVector* GetTargetingLocation(FVector* result, AActor* Attacker) { return NativeCall<FVector*, FVector*, AActor*>(this, "AActor.GetTargetingLocation", result, Attacker); }
    UPrimitiveComponent* GetVisibleComponentByClass(TSubclassOf<UPrimitiveComponent> ComponentClass) { return NativeCall<UPrimitiveComponent*, TSubclassOf<UPrimitiveComponent>>(this, "AActor.GetVisibleComponentByClass", ComponentClass); }
    UActorComponent* GetComponentByCustomTag(FName TheTag) { return NativeCall<UActorComponent*, FName>(this, "AActor.GetComponentByCustomTag", TheTag); }
    TArray<UActorComponent*>* GetComponentsByClass(TArray<UActorComponent*>* result, TSubclassOf<UActorComponent> ComponentClass) { return NativeCall<TArray<UActorComponent*>*, TArray<UActorComponent*>*, TSubclassOf<UActorComponent>>(this, "AActor.GetComponentsByClass", result, ComponentClass); }
    TArray<UActorComponent*>* GetComponentsByCustomTag(TArray<UActorComponent*>* result, FName TheTag) { return NativeCall<TArray<UActorComponent*>*, TArray<UActorComponent*>*, FName>(this, "AActor.GetComponentsByCustomTag", result, TheTag); }
    void DisableComponentsSimulatePhysics() { NativeCall<void>(this, "AActor.DisableComponentsSimulatePhysics"); }
    void PostSpawnInitialize(FVector* SpawnLocation, FRotator* SpawnRotation, AActor* InOwner, APawn* InInstigator, bool bRemoteOwned, bool bNoFail, bool bDeferConstruction, bool bDeferBeginPlay) { NativeCall<void, FVector*, FRotator*, AActor*, APawn*, bool, bool, bool, bool>(this, "AActor.PostSpawnInitialize", SpawnLocation, SpawnRotation, InOwner, InInstigator, bRemoteOwned, bNoFail, bDeferConstruction, bDeferBeginPlay); }
    void FinishSpawning(FTransform* Transform, bool bIsDefaultTransform) { NativeCall<void, FTransform*, bool>(this, "AActor.FinishSpawning", Transform, bIsDefaultTransform); }
    void DoExecuteActorConstruction(FTransform* Transform, bool bIsDefaultTransform) { NativeCall<void, FTransform*, bool>(this, "AActor.DoExecuteActorConstruction", Transform, bIsDefaultTransform); }
    void PreSave() { NativeCall<void>(this, "AActor.PreSave"); }
    void PostActorConstruction() { NativeCall<void>(this, "AActor.PostActorConstruction"); }
    void SetReplicates(bool bInReplicates) { NativeCall<void, bool>(this, "AActor.SetReplicates", bInReplicates); }
    void CopyRemoteRoleFrom(AActor* CopyFromActor) { NativeCall<void, AActor*>(this, "AActor.CopyRemoteRoleFrom", CopyFromActor); }
    void PostNetInit() { NativeCall<void>(this, "AActor.PostNetInit"); }
    void BeginPlay() { NativeCall<void>(this, "AActor.BeginPlay"); }
    void MatineeUpdated() { NativeCall<void>(this, "AActor.MatineeUpdated"); }
    void ForceReplicateNowWithChannel() { NativeCall<void>(this, "AActor.ForceReplicateNowWithChannel"); }
    void EnableInput(APlayerController* PlayerController) { NativeCall<void, APlayerController*>(this, "AActor.EnableInput", PlayerController); }
    void DisableInput(APlayerController* PlayerController) { NativeCall<void, APlayerController*>(this, "AActor.DisableInput", PlayerController); }
    float GetInputAxisValue(FName InputAxisName) { return NativeCall<float, FName>(this, "AActor.GetInputAxisValue", InputAxisName); }
    float GetInputAxisKeyValue(FKey InputAxisKey) { return NativeCall<float, FKey>(this, "AActor.GetInputAxisKeyValue", InputAxisKey); }
    FVector* GetInputVectorAxisValue(FVector* result, FKey InputAxisKey) { return NativeCall<FVector*, FVector*, FKey>(this, "AActor.GetInputVectorAxisValue", result, InputAxisKey); }
    bool SetActorLocation(FVector* NewLocation, bool bSweep) { return NativeCall<bool, FVector*, bool>(this, "AActor.SetActorLocation", NewLocation, bSweep); }
    bool SetActorRotation(FRotator NewRotation) { return NativeCall<bool, FRotator>(this, "AActor.SetActorRotation", NewRotation); }
    bool SetActorRotation(FQuat* NewRotation) { return NativeCall<bool, FQuat*>(this, "AActor.SetActorRotation", NewRotation); }
    bool SetActorLocationAndRotation(FVector* NewLocation, FRotator NewRotation, bool bSweep) { return NativeCall<bool, FVector*, FRotator, bool>(this, "AActor.SetActorLocationAndRotation", NewLocation, NewRotation, bSweep); }
    void SetActorScale3D(FVector* NewScale3D) { NativeCall<void, FVector*>(this, "AActor.SetActorScale3D", NewScale3D); }
    FVector* GetActorScale3D(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AActor.GetActorScale3D", result); }
    void SetActorRelativeLocation(FVector NewRelativeLocation, bool bSweep) { NativeCall<void, FVector, bool>(this, "AActor.SetActorRelativeLocation", NewRelativeLocation, bSweep); }
    void SetActorRelativeRotation(FRotator NewRelativeRotation, bool bSweep) { NativeCall<void, FRotator, bool>(this, "AActor.SetActorRelativeRotation", NewRelativeRotation, bSweep); }
    void SetActorRelativeScale3D(FVector NewRelativeScale) { NativeCall<void, FVector>(this, "AActor.SetActorRelativeScale3D", NewRelativeScale); }
    void SetActorHiddenInGame(bool bNewHidden) { NativeCall<void, bool>(this, "AActor.SetActorHiddenInGame", bNewHidden); }
    void SetActorEnableCollision(bool bNewActorEnableCollision) { NativeCall<void, bool>(this, "AActor.SetActorEnableCollision", bNewActorEnableCollision); }
    bool Destroy(bool bNetForce, bool bShouldModifyLevel) { return NativeCall<bool, bool, bool>(this, "AActor.Destroy", bNetForce, bShouldModifyLevel); }
    bool HasAuthority() { return NativeCall<bool>(this, "AActor.HasAuthority"); }
    bool SetRootComponent(USceneComponent* NewRootComponent) { return NativeCall<bool, USceneComponent*>(this, "AActor.SetRootComponent", NewRootComponent); }
    FVector* GetActorForwardVector(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AActor.GetActorForwardVector", result); }
    FVector* GetActorUpVector(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AActor.GetActorUpVector", result); }
    FVector* GetActorRightVector(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AActor.GetActorRightVector", result); }
    void GetActorBounds(bool bOnlyCollidingComponents, FVector* Origin, FVector* BoxExtent) { NativeCall<void, bool, FVector*, FVector*>(this, "AActor.GetActorBounds", bOnlyCollidingComponents, Origin, BoxExtent); }
    AWorldSettings* GetWorldSettings() { return NativeCall<AWorldSettings*>(this, "AActor.GetWorldSettings"); }
    void PlaySoundOnActor(USoundCue* InSoundCue, float VolumeMultiplier, float PitchMultiplier) { NativeCall<void, USoundCue*, float, float>(this, "AActor.PlaySoundOnActor", InSoundCue, VolumeMultiplier, PitchMultiplier); }
    void PlaySoundAtLocation(USoundCue* InSoundCue, FVector SoundLocation, float VolumeMultiplier, float PitchMultiplier) { NativeCall<void, USoundCue*, FVector, float, float>(this, "AActor.PlaySoundAtLocation", InSoundCue, SoundLocation, VolumeMultiplier, PitchMultiplier); }
    void UnregisterAllComponents(bool bDetachFromOtherParent) { NativeCall<void, bool>(this, "AActor.UnregisterAllComponents", bDetachFromOtherParent); }
    void RegisterAllComponents() { NativeCall<void>(this, "AActor.RegisterAllComponents"); }
    void MarkComponentsAsPendingKill() { NativeCall<void>(this, "AActor.MarkComponentsAsPendingKill"); }
    void ReregisterAllComponents() { NativeCall<void>(this, "AActor.ReregisterAllComponents"); }
    void MarkComponentsRenderStateDirty() { NativeCall<void>(this, "AActor.MarkComponentsRenderStateDirty"); }
    void InitializeComponents() { NativeCall<void>(this, "AActor.InitializeComponents"); }
    void UninitializeComponents(EEndPlayReason::Type EndPlayReason) { NativeCall<void, EEndPlayReason::Type>(this, "AActor.UninitializeComponents", EndPlayReason); }
    void InvalidateLightingCacheDetailed(bool bTranslationOnly) { NativeCall<void, bool>(this, "AActor.InvalidateLightingCacheDetailed", bTranslationOnly); }
    bool ActorLineTraceSingle(FHitResult* OutHit, FVector* Start, FVector* End, ECollisionChannel TraceChannel, FCollisionQueryParams* Params) { return NativeCall<bool, FHitResult*, FVector*, FVector*, ECollisionChannel, FCollisionQueryParams*>(this, "AActor.ActorLineTraceSingle", OutHit, Start, End, TraceChannel, Params); }
    void SetLifeSpan(float InLifespan) { NativeCall<void, float>(this, "AActor.SetLifeSpan", InLifespan); }
    float GetLifeSpan() { return NativeCall<float>(this, "AActor.GetLifeSpan"); }
    void PostInitializeComponents() { NativeCall<void>(this, "AActor.PostInitializeComponents"); }
    void Stasis() { NativeCall<void>(this, "AActor.Stasis"); }
    void Unstasis() { NativeCall<void>(this, "AActor.Unstasis"); }
    void PreInitializeComponents() { NativeCall<void>(this, "AActor.PreInitializeComponents"); }
    UWorld* K2_GetWorld() { return NativeCall<UWorld*>(this, "AActor.K2_GetWorld"); }
    float GetDistanceTo(AActor* OtherActor) { return NativeCall<float, AActor*>(this, "AActor.GetDistanceTo", OtherActor); }
    float GetHorizontalDistanceTo(AActor* OtherActor) { return NativeCall<float, AActor*>(this, "AActor.GetHorizontalDistanceTo", OtherActor); }
    float GetVerticalDistanceTo(AActor* OtherActor) { return NativeCall<float, AActor*>(this, "AActor.GetVerticalDistanceTo", OtherActor); }
    float GetDotProductTo(AActor* OtherActor) { return NativeCall<float, AActor*>(this, "AActor.GetDotProductTo", OtherActor); }
    float GetHorizontalDotProductTo(AActor* OtherActor) { return NativeCall<float, AActor*>(this, "AActor.GetHorizontalDotProductTo", OtherActor); }
    FTransform* GetInterpolatedTransform(FTransform* result) { return NativeCall<FTransform*, FTransform*>(this, "AActor.GetInterpolatedTransform", result); }
    APlayerController* GetOwnerController() { return NativeCall<APlayerController*>(this, "AActor.GetOwnerController"); }
    bool AlwaysReplicatePropertyConditional(UProperty* forProperty) { return NativeCall<bool, UProperty*>(this, "AActor.AlwaysReplicatePropertyConditional", forProperty); }
    bool TryMultiUse(APlayerController* ForPC, int UseIndex) { return NativeCall<bool, APlayerController*, int>(this, "AActor.TryMultiUse", ForPC, UseIndex); }
    void ClientMultiUse(APlayerController* ForPC, int UseIndex) { NativeCall<void, APlayerController*, int>(this, "AActor.ClientMultiUse", ForPC, UseIndex); }
    bool GetMultiUseCenterText(APlayerController* ForPC, int UseIndex, FString* OutCenterText, FLinearColor* OutCenterTextColor) { return NativeCall<bool, APlayerController*, int, FString*, FLinearColor*>(this, "AActor.GetMultiUseCenterText", ForPC, UseIndex, OutCenterText, OutCenterTextColor); }
    bool AllowSaving() { return NativeCall<bool>(this, "AActor.AllowSaving"); }
    void ChangeActorTeam(int NewTeam) { NativeCall<void, int>(this, "AActor.ChangeActorTeam", NewTeam); }
    void TargetingTeamChanged() { NativeCall<void>(this, "AActor.TargetingTeamChanged"); }
    void ForceDestroy() { NativeCall<void>(this, "AActor.ForceDestroy"); }
    bool GetIsMapActor() { return NativeCall<bool>(this, "AActor.GetIsMapActor"); }
    void SendExecCommand(FName CommandName, FNetExecParams* ExecParams, bool bIsReliable) { NativeCall<void, FName, FNetExecParams*, bool>(this, "AActor.SendExecCommand", CommandName, ExecParams, bIsReliable); }
    void ServerSendSimpleExecCommandToEveryone(FName CommandName, bool bIsReliable, bool bForceSendToLocalPlayer, bool bIgnoreRelevancy) { NativeCall<void, FName, bool, bool, bool>(this, "AActor.ServerSendSimpleExecCommandToEveryone", CommandName, bIsReliable, bForceSendToLocalPlayer, bIgnoreRelevancy); }
    bool IsPrimalCharacterOrStructure() { return NativeCall<bool>(this, "AActor.IsPrimalCharacterOrStructure"); }
    void SetTickFunctionEnabled(bool bEnableTick) { NativeCall<void, bool>(this, "AActor.SetTickFunctionEnabled", bEnableTick); }
    bool IsOwnedOrControlledBy(AActor* TestOwner) { return NativeCall<bool, AActor*>(this, "AActor.IsOwnedOrControlledBy", TestOwner); }
    bool PreventCharacterBasing(AActor* OtherActor, UPrimitiveComponent* BasedOnComponent) { return NativeCall<bool, AActor*, UPrimitiveComponent*>(this, "AActor.PreventCharacterBasing", OtherActor, BasedOnComponent); }
    bool BPIsA(TSubclassOf<AActor> anActorClass) { return NativeCall<bool, TSubclassOf<AActor>>(this, "AActor.BPIsA", anActorClass); }
    void MulticastProperty(FName PropertyName) { NativeCall<void, FName>(this, "AActor.MulticastProperty", PropertyName); }
    void MulticastPropertyToPlayer(FName PropertyName, APlayerController* PC) { NativeCall<void, FName, APlayerController*>(this, "AActor.MulticastPropertyToPlayer", PropertyName, PC); }
    void PropertyServerToClients_Implementation(AActor* ActorToRep, FName PropertyName, TArray<unsigned char>* ReplicationData) { NativeCall<void, AActor*, FName, TArray<unsigned char>*>(this, "AActor.PropertyServerToClients_Implementation", ActorToRep, PropertyName, ReplicationData); }
    float GetNetStasisAndRangeMultiplier() { return NativeCall<float>(this, "AActor.GetNetStasisAndRangeMultiplier"); }
    void StopActorSound(USoundBase* SoundAsset, float FadeOutTime) { NativeCall<void, USoundBase*, float>(this, "AActor.StopActorSound", SoundAsset, FadeOutTime); }
    void GetAllSceneComponents(TArray<USceneComponent*>* OutComponents) { NativeCall<void, TArray<USceneComponent*>*>(this, "AActor.GetAllSceneComponents", OutComponents); }
    void ActorPlaySound_Implementation(USoundBase* SoundAsset, bool bAttach, FName BoneName, FVector LocOffset) { NativeCall<void, USoundBase*, bool, FName, FVector>(this, "AActor.ActorPlaySound_Implementation", SoundAsset, bAttach, BoneName, LocOffset); }
    void NetAttachRootComponentTo_Implementation(USceneComponent* InParent, FName InSocketName, FVector RelativeLocation, FRotator RelativeRotation) { NativeCall<void, USceneComponent*, FName, FVector, FRotator>(this, "AActor.NetAttachRootComponentTo_Implementation", InParent, InSocketName, RelativeLocation, RelativeRotation); }
    void NetDetachRootComponentFromAny_Implementation() { NativeCall<void>(this, "AActor.NetDetachRootComponentFromAny_Implementation"); }
    FVector* GetHUDWorldDrawLocation(FVector* result, FName* HUDTag) { return NativeCall<FVector*, FVector*, FName*>(this, "AActor.GetHUDWorldDrawLocation", result, HUDTag); }
    void ResetPropertiesForConstruction() { NativeCall<void>(this, "AActor.ResetPropertiesForConstruction"); }
    void DestroyConstructedComponents() { NativeCall<void>(this, "AActor.DestroyConstructedComponents"); }
    void RerunConstructionScripts() { NativeCall<void>(this, "AActor.RerunConstructionScripts"); }
    UActorComponent* CreateComponentFromTemplate(UActorComponent* Template, FString* InName) { return NativeCall<UActorComponent*, UActorComponent*, FString*>(this, "AActor.CreateComponentFromTemplate", Template, InName); }
    UActorComponent* AddComponent(FName TemplateName, bool bManualAttachment, FTransform* RelativeTransform, UObject* ComponentTemplateContext) { return NativeCall<UActorComponent*, FName, bool, FTransform*, UObject*>(this, "AActor.AddComponent", TemplateName, bManualAttachment, RelativeTransform, ComponentTemplateContext); }
    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"); }
    bool IsNetRelevantFor(APlayerController* RealViewer, AActor* Viewer, FVector* SrcLocation) { return NativeCall<bool, APlayerController*, AActor*, FVector*>(this, "AActor.IsNetRelevantFor", RealViewer, Viewer, SrcLocation); }
    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "AActor.GetLifetimeReplicatedProps", OutLifetimeProps); }
    void GetSubobjectsWithStableNamesForNetworking(TArray<UObject*>* ObjList) { NativeCall<void, TArray<UObject*>*>(this, "AActor.GetSubobjectsWithStableNamesForNetworking", ObjList); }
    void OnSubobjectCreatedFromReplication(UObject* NewSubobject) { NativeCall<void, UObject*>(this, "AActor.OnSubobjectCreatedFromReplication", NewSubobject); }
    void OnSubobjectDestroyFromReplication(UObject* NewSubobject) { NativeCall<void, UObject*>(this, "AActor.OnSubobjectDestroyFromReplication", NewSubobject); }
    bool IsNameStableForNetworking() { return NativeCall<bool>(this, "AActor.IsNameStableForNetworking"); }
    void GetComponents(TArray<UActorComponent*>* OutComponents) { NativeCall<void, TArray<UActorComponent*>*>(this, "AActor.GetComponents", OutComponents); }
    void GatherCurrentMovement() { NativeCall<void>(this, "AActor.GatherCurrentMovement"); }
    void ForceReplicateNow(bool bForceCreateChannel, bool bForceCreateChannelIfRelevant) { NativeCall<void, bool, bool>(this, "AActor.ForceReplicateNow", bForceCreateChannel, bForceCreateChannelIfRelevant); }
    void ForceNetUpdate(bool bDormantDontReplicateProperties, bool bAbsoluteForceNetUpdate, bool bDontUpdateChannel) { NativeCall<void, bool, bool, bool>(this, "AActor.ForceNetUpdate", bDormantDontReplicateProperties, bAbsoluteForceNetUpdate, bDontUpdateChannel); }
    static void StaticRegisterNativesAActor() { NativeCall<void>(nullptr, "AActor.StaticRegisterNativesAActor"); }
    void ActorPlaySound(USoundBase* SoundAsset, bool bAttach, FName BoneName, FVector LocOffset) { NativeCall<void, USoundBase*, bool, FName, FVector>(this, "AActor.ActorPlaySound", SoundAsset, bAttach, BoneName, LocOffset); }
    void ActorPlaySoundUnreliable(USoundBase* SoundAsset, bool bAttach, FName BoneName, FVector LocOffset) { NativeCall<void, USoundBase*, bool, FName, FVector>(this, "AActor.ActorPlaySoundUnreliable", SoundAsset, bAttach, BoneName, LocOffset); }
    bool AllowGrappling() { return NativeCall<bool>(this, "AActor.AllowGrappling"); }
    bool AllowIgnoreCharacterEncroachment(UPrimitiveComponent* HitComponent, AActor* EncroachingCharacter) { return NativeCall<bool, UPrimitiveComponent*, AActor*>(this, "AActor.AllowIgnoreCharacterEncroachment", HitComponent, EncroachingCharacter); }
    bool AllowManualMultiUseActivation(APlayerController* ForPC) { return NativeCall<bool, APlayerController*>(this, "AActor.AllowManualMultiUseActivation", ForPC); }
    FVector* BP_GetHUDWorldDrawLocation(FVector* result, FName HUDTag) { return NativeCall<FVector*, FVector*, FName>(this, "AActor.BP_GetHUDWorldDrawLocation", result, HUDTag); }
    FVector* BP_OverrideTargetingLocation(FVector* result, AActor* Attacker) { return NativeCall<FVector*, FVector*, AActor*>(this, "AActor.BP_OverrideTargetingLocation", result, Attacker); }
    void BPAttachedRootComponent() { NativeCall<void>(this, "AActor.BPAttachedRootComponent"); }
    void BPChangedActorTeam() { NativeCall<void>(this, "AActor.BPChangedActorTeam"); }
    bool BPConsumeSetPinCode(APlayerController* ForPC, int appledPinCode, bool bIsSetting, int TheCustomIndex) { return NativeCall<bool, APlayerController*, int, bool, int>(this, "AActor.BPConsumeSetPinCode", ForPC, appledPinCode, bIsSetting, TheCustomIndex); }
    bool BPConsumeUsePinCode(AActor* FromKeypadActor, APlayerController* ForPC, int appledPinCode, bool bIsActivating) { return NativeCall<bool, AActor*, APlayerController*, int, bool>(this, "AActor.BPConsumeUsePinCode", FromKeypadActor, ForPC, appledPinCode, bIsActivating); }
    bool BPForceAllowsInventoryUse(UObject* InventoryItemObject) { return NativeCall<bool, UObject*>(this, "AActor.BPForceAllowsInventoryUse", InventoryItemObject); }
    int BPGetExtraSpecialBlueprintInt() { return NativeCall<int>(this, "AActor.BPGetExtraSpecialBlueprintInt"); }
    bool BPGetMultiUseCenterText(APlayerController* ForPC, int UseIndex, FString* OutCenterText, FLinearColor* OutCenterTextColor) { return NativeCall<bool, APlayerController*, int, FString*, FLinearColor*>(this, "AActor.BPGetMultiUseCenterText", ForPC, UseIndex, OutCenterText, OutCenterTextColor); }
    void BPInventoryItemDropped(UObject* InventoryItemObject) { NativeCall<void, UObject*>(this, "AActor.BPInventoryItemDropped", InventoryItemObject); }
    void BPInventoryItemUsed(UObject* InventoryItemObject) { NativeCall<void, UObject*>(this, "AActor.BPInventoryItemUsed", InventoryItemObject); }
    FVector* BPOverrideUILocation(FVector* result, APlayerController* ForPC) { return NativeCall<FVector*, FVector*, APlayerController*>(this, "AActor.BPOverrideUILocation", result, ForPC); }
    void DrawBasicFloatingHUD(AHUD* ForHUD) { NativeCall<void, AHUD*>(this, "AActor.DrawBasicFloatingHUD", ForHUD); }
    float GetUsablePriority() { return NativeCall<float>(this, "AActor.GetUsablePriority"); }
    void K2_OnBecomeViewTarget(APlayerController* PC) { NativeCall<void, APlayerController*>(this, "AActor.K2_OnBecomeViewTarget", PC); }
    void K2_OnEndViewTarget(APlayerController* PC) { NativeCall<void, APlayerController*>(this, "AActor.K2_OnEndViewTarget", PC); }
    void ModifyHudMultiUseLoc(FVector2D* theVec, APlayerController* PC, int index) { NativeCall<void, FVector2D*, APlayerController*, int>(this, "AActor.ModifyHudMultiUseLoc", theVec, PC, index); }
    void MulticastDrawDebugArrow(FVector LineStart, FVector LineEnd, float ArrowSize, FLinearColor LineColor, float Duration, bool enableInShipping) { NativeCall<void, FVector, FVector, float, FLinearColor, float, bool>(this, "AActor.MulticastDrawDebugArrow", LineStart, LineEnd, ArrowSize, LineColor, Duration, enableInShipping); }
    void MulticastDrawDebugBox(FVector Center, FVector Extent, FLinearColor LineColor, FRotator Rotation, float Duration, bool enableInShipping) { NativeCall<void, FVector, FVector, FLinearColor, FRotator, float, bool>(this, "AActor.MulticastDrawDebugBox", Center, Extent, LineColor, Rotation, Duration, enableInShipping); }
    void MulticastDrawDebugCapsule(FVector Center, float HalfHeight, float Radius, FRotator Rotation, FLinearColor LineColor, float Duration, bool enableInShipping) { NativeCall<void, FVector, float, float, FRotator, FLinearColor, float, bool>(this, "AActor.MulticastDrawDebugCapsule", Center, HalfHeight, Radius, Rotation, LineColor, Duration, enableInShipping); }
    void MulticastDrawDebugCapsuleWithExtents(FVector Top, FVector Bottom, float Radius, FLinearColor LineColor, float Duration, bool bPersistent) { NativeCall<void, FVector, FVector, float, FLinearColor, float, bool>(this, "AActor.MulticastDrawDebugCapsuleWithExtents", Top, Bottom, Radius, LineColor, Duration, bPersistent); }
    void MulticastDrawDebugCoordinateSystem(FVector AxisLoc, FRotator AxisRot, float Scale, float Duration, float Thickness) { NativeCall<void, FVector, FRotator, float, float, float>(this, "AActor.MulticastDrawDebugCoordinateSystem", AxisLoc, AxisRot, Scale, Duration, Thickness); }
    void MulticastDrawDebugCylinder(FVector Start, FVector End, float Radius, int Segments, FLinearColor LineColor, float Duration) { NativeCall<void, FVector, FVector, float, int, FLinearColor, float>(this, "AActor.MulticastDrawDebugCylinder", Start, End, Radius, Segments, LineColor, Duration); }
    void MulticastDrawDebugLine(FVector LineStart, FVector LineEnd, FLinearColor LineColor, float Duration, float Thickness, bool enableInShipping) { NativeCall<void, FVector, FVector, FLinearColor, float, float, bool>(this, "AActor.MulticastDrawDebugLine", LineStart, LineEnd, LineColor, Duration, Thickness, enableInShipping); }
    void MulticastDrawDebugPoint(FVector Position, float Size, FLinearColor PointColor, float Duration, bool enableInShipping) { NativeCall<void, FVector, float, FLinearColor, float, bool>(this, "AActor.MulticastDrawDebugPoint", Position, Size, PointColor, Duration, enableInShipping); }
    void MulticastDrawDebugSphere(FVector Center, float Radius, int Segments, FLinearColor LineColor, float Duration, bool enableInShipping) { NativeCall<void, FVector, float, int, FLinearColor, float, bool>(this, "AActor.MulticastDrawDebugSphere", Center, Radius, Segments, LineColor, Duration, enableInShipping); }
    void MulticastDrawDebugString(FVector TextLocation, FString* Text, AActor* TestBaseActor, FLinearColor TextColor, float Duration, bool enableInShipping) { NativeCall<void, FVector, FString*, AActor*, FLinearColor, float, bool>(this, "AActor.MulticastDrawDebugString", TextLocation, Text, TestBaseActor, TextColor, Duration, enableInShipping); }
    void NetAttachRootComponentTo(USceneComponent* InParent, FName InSocketName, FVector RelativeLocation, FRotator RelativeRotation) { NativeCall<void, USceneComponent*, FName, FVector, FRotator>(this, "AActor.NetAttachRootComponentTo", InParent, InSocketName, RelativeLocation, RelativeRotation); }
    void OnInventoryItemGrind() { NativeCall<void>(this, "AActor.OnInventoryItemGrind"); }
    void PerformanceThrottledTick() { NativeCall<void>(this, "AActor.PerformanceThrottledTick"); }
    void PropertyServerToClients(AActor* ActorToRep, FName PropertyName, TArray<unsigned char>* ReplicationData) { NativeCall<void, AActor*, FName, TArray<unsigned char>*>(this, "AActor.PropertyServerToClients", ActorToRep, PropertyName, ReplicationData); }
    void ReceiveActorBeginCursorOver() { NativeCall<void>(this, "AActor.ReceiveActorBeginCursorOver"); }
    void ReceiveActorBeginOverlap(AActor* OtherActor) { NativeCall<void, AActor*>(this, "AActor.ReceiveActorBeginOverlap", OtherActor); }
    void ReceiveActorEndCursorOver() { NativeCall<void>(this, "AActor.ReceiveActorEndCursorOver"); }
    void ReceiveActorEndOverlap(AActor* OtherActor) { NativeCall<void, AActor*>(this, "AActor.ReceiveActorEndOverlap", OtherActor); }
    void ReceiveActorOnClicked() { NativeCall<void>(this, "AActor.ReceiveActorOnClicked"); }
    void ReceiveActorOnInputTouchBegin(ETouchIndex::Type FingerIndex) { NativeCall<void, ETouchIndex::Type>(this, "AActor.ReceiveActorOnInputTouchBegin", FingerIndex); }
    void ReceiveActorOnInputTouchEnd(ETouchIndex::Type FingerIndex) { NativeCall<void, ETouchIndex::Type>(this, "AActor.ReceiveActorOnInputTouchEnd", FingerIndex); }
    void ReceiveActorOnInputTouchEnter(ETouchIndex::Type FingerIndex) { NativeCall<void, ETouchIndex::Type>(this, "AActor.ReceiveActorOnInputTouchEnter", FingerIndex); }
    void ReceiveActorOnInputTouchLeave(ETouchIndex::Type FingerIndex) { NativeCall<void, ETouchIndex::Type>(this, "AActor.ReceiveActorOnInputTouchLeave", FingerIndex); }
    void ReceiveActorOnReleased() { NativeCall<void>(this, "AActor.ReceiveActorOnReleased"); }
    void ReceiveAnyDamage(float Damage, UDamageType* DamageType, AController* InstigatedBy, AActor* DamageCauser) { NativeCall<void, float, UDamageType*, AController*, AActor*>(this, "AActor.ReceiveAnyDamage", Damage, DamageType, InstigatedBy, DamageCauser); }
    void ReceiveBeginPlay() { NativeCall<void>(this, "AActor.ReceiveBeginPlay"); }
    void ReceiveDestroyed() { NativeCall<void>(this, "AActor.ReceiveDestroyed"); }
    void ReceiveEndPlay(EEndPlayReason::Type EndPlayReason) { NativeCall<void, EEndPlayReason::Type>(this, "AActor.ReceiveEndPlay", EndPlayReason); }
    void ReceiveHit(UPrimitiveComponent* MyComp, AActor* Other, UPrimitiveComponent* OtherComp, bool bSelfMoved, FVector HitLocation, FVector HitNormal, FVector NormalImpulse, FHitResult* Hit) { NativeCall<void, UPrimitiveComponent*, AActor*, UPrimitiveComponent*, bool, FVector, FVector, FVector, FHitResult*>(this, "AActor.ReceiveHit", MyComp, Other, OtherComp, bSelfMoved, HitLocation, HitNormal, NormalImpulse, Hit); }
    void ReceiveInput(FString* InputName, float Value, FVector VectorValue, bool bStarted, bool bEnded) { NativeCall<void, FString*, float, FVector, bool, bool>(this, "AActor.ReceiveInput", InputName, Value, VectorValue, bStarted, bEnded); }
    void ReceivePointDamage(float Damage, UDamageType* DamageType, FVector HitLocation, FVector HitNormal, UPrimitiveComponent* HitComponent, FName BoneName, FVector ShotFromDirection, AController* InstigatedBy, AActor* DamageCauser) { NativeCall<void, float, UDamageType*, FVector, FVector, UPrimitiveComponent*, FName, FVector, AController*, AActor*>(this, "AActor.ReceivePointDamage", Damage, DamageType, HitLocation, HitNormal, HitComponent, BoneName, ShotFromDirection, InstigatedBy, DamageCauser); }
    void ReceiveRadialDamage(float DamageReceived, UDamageType* DamageType, FVector Origin, FHitResult* HitInfo, AController* InstigatedBy, AActor* DamageCauser) { NativeCall<void, float, UDamageType*, FVector, FHitResult*, AController*, AActor*>(this, "AActor.ReceiveRadialDamage", DamageReceived, DamageType, Origin, HitInfo, InstigatedBy, DamageCauser); }
    void ReceiveTick(float DeltaSeconds) { NativeCall<void, float>(this, "AActor.ReceiveTick", DeltaSeconds); }
    void RecieveMatineeUpdated() { NativeCall<void>(this, "AActor.RecieveMatineeUpdated"); }
    void ThrottledTick() { NativeCall<void>(this, "AActor.ThrottledTick"); }
    void UserConstructionScript() { NativeCall<void>(this, "AActor.UserConstructionScript"); }
};
 
struct AInfo : AActor
{
 
    // Functions
 
    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "AInfo.StaticClass"); }
};
 
struct APawn : AActor
{
    float& BaseEyeHeightField() { return *GetNativePointerField<float*>(this, "APawn.BaseEyeHeight"); }
    TSubclassOf<AController> & AIControllerClassField() { return *GetNativePointerField<TSubclassOf<AController>*>(this, "APawn.AIControllerClass"); }
    APlayerState * PlayerStateField() { return *GetNativePointerField<APlayerState**>(this, "APawn.PlayerState"); }
    char& RemoteViewPitchField() { return *GetNativePointerField<char*>(this, "APawn.RemoteViewPitch"); }
    AController * LastHitByField() { return *GetNativePointerField<AController**>(this, "APawn.LastHitBy"); }
    AController * ControllerField() { return *GetNativePointerField<AController**>(this, "APawn.Controller"); }
    float& AllowedYawErrorField() { return *GetNativePointerField<float*>(this, "APawn.AllowedYawError"); }
    bool& bClearOnConsumeField() { return *GetNativePointerField<bool*>(this, "APawn.bClearOnConsume"); }
    TWeakObjectPtr<AActor> & TetherActorField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "APawn.TetherActor"); }
    float& TetherRadiusField() { return *GetNativePointerField<float*>(this, "APawn.TetherRadius"); }
    float& TetherHeightField() { return *GetNativePointerField<float*>(this, "APawn.TetherHeight"); }
    FVector & ControlInputVectorField() { return *GetNativePointerField<FVector*>(this, "APawn.ControlInputVector"); }
    FVector & LastControlInputVectorField() { return *GetNativePointerField<FVector*>(this, "APawn.LastControlInputVector"); }
    TWeakObjectPtr<AController> & SpawnedForControllerField() { return *GetNativePointerField<TWeakObjectPtr<AController>*>(this, "APawn.SpawnedForController"); }
 
    // Bit fields
 
    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> bPreventMovementStoppingOnPossess() { return { this, "APawn.bPreventMovementStoppingOnPossess" }; }
    BitFieldValue<bool, unsigned __int32> bInputEnabled() { return { this, "APawn.bInputEnabled" }; }
    BitFieldValue<bool, unsigned __int32> bProcessingOutsideWorldBounds() { return { this, "APawn.bProcessingOutsideWorldBounds" }; }
 
    // Functions
 
    FVector * GetNavAgentLocation(FVector * result) { return NativeCall<FVector*, FVector*>(this, "APawn.GetNavAgentLocation", result); }
    void PreInitializeComponents() { NativeCall<void>(this, "APawn.PreInitializeComponents"); }
    void PostInitializeComponents() { NativeCall<void>(this, "APawn.PostInitializeComponents"); }
    void PostLoad() { NativeCall<void>(this, "APawn.PostLoad"); }
    void PostRegisterAllComponents() { NativeCall<void>(this, "APawn.PostRegisterAllComponents"); }
    void UpdateNavAgent() { NativeCall<void>(this, "APawn.UpdateNavAgent"); }
    FVector * GetVelocity(FVector * result, bool bIsForRagdoll) { return NativeCall<FVector*, FVector*, bool>(this, "APawn.GetVelocity", result, bIsForRagdoll); }
    bool IsLocallyControlled() { return NativeCall<bool>(this, "APawn.IsLocallyControlled"); }
    bool ReachedDesiredRotation() { return NativeCall<bool>(this, "APawn.ReachedDesiredRotation"); }
    float GetDefaultHalfHeight() { return NativeCall<float>(this, "APawn.GetDefaultHalfHeight"); }
    bool ShouldTickIfViewportsOnly() { return NativeCall<bool>(this, "APawn.ShouldTickIfViewportsOnly"); }
    FVector * GetPawnViewLocation(FVector * result, bool bAllTransforms) { return NativeCall<FVector*, FVector*, bool>(this, "APawn.GetPawnViewLocation", result, bAllTransforms); }
    FRotator * GetViewRotation(FRotator * result) { return NativeCall<FRotator*, FRotator*>(this, "APawn.GetViewRotation", result); }
    void SpawnDefaultController() { NativeCall<void>(this, "APawn.SpawnDefaultController"); }
    void TurnOff() { NativeCall<void>(this, "APawn.TurnOff"); }
    void BecomeViewTarget(APlayerController * PC) { NativeCall<void, APlayerController*>(this, "APawn.BecomeViewTarget", PC); }
    void PawnClientRestart() { NativeCall<void>(this, "APawn.PawnClientRestart"); }
    void Destroyed() { NativeCall<void>(this, "APawn.Destroyed"); }
    bool ShouldTakeDamage(float Damage, FDamageEvent * DamageEvent, AController * EventInstigator, AActor * DamageCauser) { return NativeCall<bool, float, FDamageEvent*, AController*, AActor*>(this, "APawn.ShouldTakeDamage", Damage, DamageEvent, EventInstigator, DamageCauser); }
    float TakeDamage(float Damage, FDamageEvent * DamageEvent, AController * EventInstigator, AActor * DamageCauser) { return NativeCall<float, float, FDamageEvent*, AController*, AActor*>(this, "APawn.TakeDamage", Damage, DamageEvent, EventInstigator, DamageCauser); }
    AController * GetCharacterController() { return NativeCall<AController*>(this, "APawn.GetCharacterController"); }
    FRotator * GetControlRotation(FRotator * result) { return NativeCall<FRotator*, FRotator*>(this, "APawn.GetControlRotation", result); }
    void OnRep_Controller() { NativeCall<void>(this, "APawn.OnRep_Controller"); }
    void PossessedBy(AController * NewController) { NativeCall<void, AController*>(this, "APawn.PossessedBy", NewController); }
    void UnPossessed() { NativeCall<void>(this, "APawn.UnPossessed"); }
    UNetConnection * GetNetConnection() { return NativeCall<UNetConnection*>(this, "APawn.GetNetConnection"); }
    UPlayer * GetNetOwningPlayer() { return NativeCall<UPlayer*>(this, "APawn.GetNetOwningPlayer"); }
    void DestroyPlayerInputComponent() { NativeCall<void>(this, "APawn.DestroyPlayerInputComponent"); }
    bool IsMoveInputIgnored() { return NativeCall<bool>(this, "APawn.IsMoveInputIgnored"); }
    void SetMovementTether(AActor * InTetherActor, float Radius, float Height) { NativeCall<void, AActor*, float, float>(this, "APawn.SetMovementTether", InTetherActor, Radius, Height); }
    void ClearMovementTether() { NativeCall<void>(this, "APawn.ClearMovementTether"); }
    AActor * GetTetherObject() { return NativeCall<AActor*>(this, "APawn.GetTetherObject"); }
    bool IsMovementTethered() { return NativeCall<bool>(this, "APawn.IsMovementTethered"); }
    bool IsWithinTether() { return NativeCall<bool>(this, "APawn.IsWithinTether"); }
    bool IsTargetWithinTether(FVector * Destination, float AdditionalRadius) { return NativeCall<bool, FVector*, float>(this, "APawn.IsTargetWithinTether", Destination, AdditionalRadius); }
    FVector * GetTetheredDestination(FVector * result, FVector * Destination, float AdditionalRadius) { return NativeCall<FVector*, FVector*, FVector*, float>(this, "APawn.GetTetheredDestination", result, Destination, AdditionalRadius); }
    FVector * GetTetheredVelocity(FVector * result, FVector * RequestedVelocity, float DeltaSeconds) { return NativeCall<FVector*, FVector*, FVector*, float>(this, "APawn.GetTetheredVelocity", result, RequestedVelocity, DeltaSeconds); }
    void AddMovementInput(FVector WorldDirection, float ScaleValue, bool bForce) { NativeCall<void, FVector, float, bool>(this, "APawn.AddMovementInput", WorldDirection, ScaleValue, bForce); }
    FVector * ConsumeMovementInputVector(FVector * result) { return NativeCall<FVector*, FVector*>(this, "APawn.ConsumeMovementInputVector", result); }
    void Internal_AddMovementInput(FVector WorldAccel, bool bForce) { NativeCall<void, FVector, bool>(this, "APawn.Internal_AddMovementInput", WorldAccel, bForce); }
    void PostInputProcessed() { NativeCall<void>(this, "APawn.PostInputProcessed"); }
    FVector * Internal_ConsumeMovementInputVector(FVector * result) { return NativeCall<FVector*, FVector*>(this, "APawn.Internal_ConsumeMovementInputVector", result); }
    void AddControllerPitchInput(float Val) { NativeCall<void, float>(this, "APawn.AddControllerPitchInput", Val); }
    void AddControllerYawInput(float Val) { NativeCall<void, float>(this, "APawn.AddControllerYawInput", Val); }
    void AddControllerRollInput(float Val) { NativeCall<void, float>(this, "APawn.AddControllerRollInput", Val); }
    void Restart() { NativeCall<void>(this, "APawn.Restart"); }
    void Tick(float DeltaSeconds) { NativeCall<void, float>(this, "APawn.Tick", DeltaSeconds); }
    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 GetActorEyesViewPoint(FVector * out_Location, FRotator * out_Rotation) { NativeCall<void, FVector*, FRotator*>(this, "APawn.GetActorEyesViewPoint", out_Location, out_Rotation); }
    FRotator * GetBaseAimRotation(FRotator * result) { return NativeCall<FRotator*, FRotator*>(this, "APawn.GetBaseAimRotation", result); }
    bool InFreeCam() { return NativeCall<bool>(this, "APawn.InFreeCam"); }
    void OutsideWorldBounds() { NativeCall<void>(this, "APawn.OutsideWorldBounds"); }
    void ClientSetRotation(FRotator NewRotation) { NativeCall<void, FRotator>(this, "APawn.ClientSetRotation", NewRotation); }
    void FaceRotation(FRotator NewControlRotation, float DeltaTime, bool bFromController) { NativeCall<void, FRotator, float, bool>(this, "APawn.FaceRotation", NewControlRotation, DeltaTime, bFromController); }
    void DetachFromControllerPendingDestroy() { NativeCall<void>(this, "APawn.DetachFromControllerPendingDestroy"); }
    AController * GetDamageInstigator(AController * InstigatedBy, UDamageType * DamageType) { return NativeCall<AController*, AController*, UDamageType*>(this, "APawn.GetDamageInstigator", InstigatedBy, DamageType); }
    void EnableInput(APlayerController * PlayerController) { NativeCall<void, APlayerController*>(this, "APawn.EnableInput", PlayerController); }
    void DisableInput(APlayerController * PlayerController) { NativeCall<void, APlayerController*>(this, "APawn.DisableInput", PlayerController); }
    bool IsWalking() { return NativeCall<bool>(this, "APawn.IsWalking"); }
    bool IsFalling() { return NativeCall<bool>(this, "APawn.IsFalling"); }
    bool IsCrouched() { return NativeCall<bool>(this, "APawn.IsCrouched"); }
    void PostNetReceiveVelocity(FVector * NewVelocity) { NativeCall<void, FVector*>(this, "APawn.PostNetReceiveVelocity", NewVelocity); }
    void PostNetReceiveLocationAndRotation() { NativeCall<void>(this, "APawn.PostNetReceiveLocationAndRotation"); }
    bool IsBasedOnActor(AActor * Other) { return NativeCall<bool, AActor*>(this, "APawn.IsBasedOnActor", Other); }
    bool IsNetRelevantFor(APlayerController * RealViewer, AActor * Viewer, FVector * SrcLocation) { return NativeCall<bool, APlayerController*, AActor*, FVector*>(this, "APawn.IsNetRelevantFor", RealViewer, Viewer, SrcLocation); }
    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty> * OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "APawn.GetLifetimeReplicatedProps", OutLifetimeProps); }
    void PawnMakeNoise(float Loudness, FVector NoiseLocation, bool bUseNoiseMakerLocation, AActor * NoiseMaker) { NativeCall<void, float, FVector, bool, AActor*>(this, "APawn.PawnMakeNoise", Loudness, NoiseLocation, bUseNoiseMakerLocation, NoiseMaker); }
    APlayerController * GetOwnerController() { return NativeCall<APlayerController*>(this, "APawn.GetOwnerController"); }
    bool IsLocallyControlledByPlayer() { return NativeCall<bool>(this, "APawn.IsLocallyControlledByPlayer"); }
    static void StaticRegisterNativesAPawn() { NativeCall<void>(nullptr, "APawn.StaticRegisterNativesAPawn"); }
    void InterceptInputEvent(FString * InputName) { NativeCall<void, FString*>(this, "APawn.InterceptInputEvent", InputName); }
};
 
struct UCheatManager : UObject
{
    float& DebugTraceDistanceField() { return *GetNativePointerField<float*>(this, "UCheatManager.DebugTraceDistance"); }
    float& DebugCapsuleHalfHeightField() { return *GetNativePointerField<float*>(this, "UCheatManager.DebugCapsuleHalfHeight"); }
    float& DebugCapsuleRadiusField() { return *GetNativePointerField<float*>(this, "UCheatManager.DebugCapsuleRadius"); }
    float& DebugTraceDrawNormalLengthField() { return *GetNativePointerField<float*>(this, "UCheatManager.DebugTraceDrawNormalLength"); }
    TEnumAsByte<enum ECollisionChannel>& DebugTraceChannelField() { return *GetNativePointerField<TEnumAsByte<enum ECollisionChannel>*>(this, "UCheatManager.DebugTraceChannel"); }
    int& CurrentTraceIndexField() { return *GetNativePointerField<int*>(this, "UCheatManager.CurrentTraceIndex"); }
    int& CurrentTracePawnIndexField() { return *GetNativePointerField<int*>(this, "UCheatManager.CurrentTracePawnIndex"); }
    float& DumpAILogsIntervalField() { return *GetNativePointerField<float*>(this, "UCheatManager.DumpAILogsInterval"); }
 
    // Bit fields
 
    BitFieldValue<bool, unsigned __int32> bDebugCapsuleSweep() { return { this, "UCheatManager.bDebugCapsuleSweep" }; }
    BitFieldValue<bool, unsigned __int32> bDebugCapsuleSweepPawn() { return { this, "UCheatManager.bDebugCapsuleSweepPawn" }; }
    BitFieldValue<bool, unsigned __int32> bDebugCapsuleTraceComplex() { return { this, "UCheatManager.bDebugCapsuleTraceComplex" }; }
    BitFieldValue<bool, unsigned __int32> bToggleAILogging() { return { this, "UCheatManager.bToggleAILogging" }; }
 
    // Functions
 
    void FreezeFrame(float delay) { NativeCall<void, float>(this, "UCheatManager.FreezeFrame", delay); }
    void Teleport() { NativeCall<void>(this, "UCheatManager.Teleport"); }
    void ChangeSize(float F) { NativeCall<void, float>(this, "UCheatManager.ChangeSize", F); }
    void Fly() { NativeCall<void>(this, "UCheatManager.Fly"); }
    void Walk() { NativeCall<void>(this, "UCheatManager.Walk"); }
    void Ghost() { NativeCall<void>(this, "UCheatManager.Ghost"); }
    void God() { NativeCall<void>(this, "UCheatManager.God"); }
    void Slomo(float T) { NativeCall<void, float>(this, "UCheatManager.Slomo", T); }
    void DamageTarget(float DamageAmount) { NativeCall<void, float>(this, "UCheatManager.DamageTarget", DamageAmount); }
    void DestroyTarget() { NativeCall<void>(this, "UCheatManager.DestroyTarget"); }
    void DestroyAll(TSubclassOf<AActor> aClass) { NativeCall<void, TSubclassOf<AActor>>(this, "UCheatManager.DestroyAll", aClass); }
    void DestroyPawns(TSubclassOf<APawn> aClass) { NativeCall<void, TSubclassOf<APawn>>(this, "UCheatManager.DestroyPawns", aClass); }
    void Summon(FString* ClassName) { NativeCall<void, FString*>(this, "UCheatManager.Summon", ClassName); }
    void PlayersOnly() { NativeCall<void>(this, "UCheatManager.PlayersOnly"); }
    void ViewSelf() { NativeCall<void>(this, "UCheatManager.ViewSelf"); }
    void ViewPlayer(FString* S) { NativeCall<void, FString*>(this, "UCheatManager.ViewPlayer", S); }
    void ViewActor(FName ActorName) { NativeCall<void, FName>(this, "UCheatManager.ViewActor", ActorName); }
    void ViewClass(TSubclassOf<AActor> DesiredClass) { NativeCall<void, TSubclassOf<AActor>>(this, "UCheatManager.ViewClass", DesiredClass); }
    void SetLevelStreamingStatus(FName PackageName, bool bShouldBeLoaded, bool bShouldBeVisible) { NativeCall<void, FName, bool, bool>(this, "UCheatManager.SetLevelStreamingStatus", PackageName, bShouldBeLoaded, bShouldBeVisible); }
    void StreamLevelIn(FName PackageName) { NativeCall<void, FName>(this, "UCheatManager.StreamLevelIn", PackageName); }
    void OnlyLoadLevel(FName PackageName) { NativeCall<void, FName>(this, "UCheatManager.OnlyLoadLevel", PackageName); }
    void StreamLevelOut(FName PackageName) { NativeCall<void, FName>(this, "UCheatManager.StreamLevelOut", PackageName); }
    void ToggleDebugCamera() { NativeCall<void>(this, "UCheatManager.ToggleDebugCamera"); }
    void EnableDebugCamera() { NativeCall<void>(this, "UCheatManager.EnableDebugCamera"); }
    void DisableDebugCamera() { NativeCall<void>(this, "UCheatManager.DisableDebugCamera"); }
    void DebugCapsuleSweep() { NativeCall<void>(this, "UCheatManager.DebugCapsuleSweep"); }
    void DebugCapsuleSweepSize(float HalfHeight, float Radius) { NativeCall<void, float, float>(this, "UCheatManager.DebugCapsuleSweepSize", HalfHeight, Radius); }
    void DebugCapsuleSweepChannel(ECollisionChannel Channel) { NativeCall<void, ECollisionChannel>(this, "UCheatManager.DebugCapsuleSweepChannel", Channel); }
    void DebugCapsuleSweepComplex(bool bTraceComplex) { NativeCall<void, bool>(this, "UCheatManager.DebugCapsuleSweepComplex", bTraceComplex); }
    void DebugCapsuleSweepCapture() { NativeCall<void>(this, "UCheatManager.DebugCapsuleSweepCapture"); }
    void DebugCapsuleSweepPawn() { NativeCall<void>(this, "UCheatManager.DebugCapsuleSweepPawn"); }
    void DebugCapsuleSweepClear() { NativeCall<void>(this, "UCheatManager.DebugCapsuleSweepClear"); }
    void TestCollisionDistance() { NativeCall<void>(this, "UCheatManager.TestCollisionDistance"); }
    void WidgetReflector() { NativeCall<void>(this, "UCheatManager.WidgetReflector"); }
    void RebuildNavigation() { NativeCall<void>(this, "UCheatManager.RebuildNavigation"); }
    void DumpOnlineSessionState() { NativeCall<void>(this, "UCheatManager.DumpOnlineSessionState"); }
    void DumpVoiceMutingState() { NativeCall<void>(this, "UCheatManager.DumpVoiceMutingState"); }
    UWorld* GetWorld() { return NativeCall<UWorld*>(this, "UCheatManager.GetWorld"); }
    void BugItGo(float X, float Y, float Z, float Pitch, float Yaw, float Roll) { NativeCall<void, float, float, float, float, float, float>(this, "UCheatManager.BugItGo", X, Y, Z, Pitch, Yaw, Roll); }
    void BugItGoString(FString* TheLocation, FString* TheRotation) { NativeCall<void, FString*, FString*>(this, "UCheatManager.BugItGoString", TheLocation, TheRotation); }
    void BugItWorker(FVector TheLocation, FRotator TheRotation) { NativeCall<void, FVector, FRotator>(this, "UCheatManager.BugItWorker", TheLocation, TheRotation); }
    void BugIt(FString* ScreenShotDescription) { NativeCall<void, FString*>(this, "UCheatManager.BugIt", ScreenShotDescription); }
    void BugItStringCreator(FVector ViewLocation, FRotator ViewRotation, FString* GoString, FString* LocString) { NativeCall<void, FVector, FRotator, FString*, FString*>(this, "UCheatManager.BugItStringCreator", ViewLocation, ViewRotation, GoString, LocString); }
    void FlushLog() { NativeCall<void>(this, "UCheatManager.FlushLog"); }
    void LogLoc() { NativeCall<void>(this, "UCheatManager.LogLoc"); }
    void SetWorldOrigin() { NativeCall<void>(this, "UCheatManager.SetWorldOrigin"); }
    static void StaticRegisterNativesUCheatManager() { NativeCall<void>(nullptr, "UCheatManager.StaticRegisterNativesUCheatManager"); }
    void ServerToggleAILogging() { NativeCall<void>(this, "UCheatManager.ServerToggleAILogging"); }
};
 
struct UShooterCheatManager : UCheatManager
{
    bool& bIsRCONCheatManagerField() { return *GetNativePointerField<bool*>(this, "UShooterCheatManager.bIsRCONCheatManager"); }
    AShooterPlayerController* MyPCField() { return *GetNativePointerField<AShooterPlayerController**>(this, "UShooterCheatManager.MyPC"); }
 
    // Functions
 
    void TakeAllStructure() { NativeCall<void>(this, "UShooterCheatManager.TakeAllStructure"); }
    void TakeAllDino() { NativeCall<void>(this, "UShooterCheatManager.TakeAllDino"); }
    void TakeTribe(int TribeTeamID) { NativeCall<void, int>(this, "UShooterCheatManager.TakeTribe", TribeTeamID); }
    void GMBuff() { NativeCall<void>(this, "UShooterCheatManager.GMBuff"); }
    void GMSummon(FString* ClassName, int Level) { NativeCall<void, FString*, int>(this, "UShooterCheatManager.GMSummon", ClassName, Level); }
    void ClearMyBuffs() { NativeCall<void>(this, "UShooterCheatManager.ClearMyBuffs"); }
    void ListMyBuffs() { NativeCall<void>(this, "UShooterCheatManager.ListMyBuffs"); }
    void ListMyTargetBuffs() { NativeCall<void>(this, "UShooterCheatManager.ListMyTargetBuffs"); }
    FString* ListBuffs(FString* result, APrimalCharacter* target) { return NativeCall<FString*, FString*, APrimalCharacter*>(this, "UShooterCheatManager.ListBuffs", result, target); }
    void DebugCompanionReactions() { NativeCall<void>(this, "UShooterCheatManager.DebugCompanionReactions"); }
    void DebugCompanionAsyncLoadedFiles() { NativeCall<void>(this, "UShooterCheatManager.DebugCompanionAsyncLoadedFiles"); }
    void ClearCryoSickness() { NativeCall<void>(this, "UShooterCheatManager.ClearCryoSickness"); }
    void Broadcast(FString* MessageText) { NativeCall<void, FString*>(this, "UShooterCheatManager.Broadcast", MessageText); }
    void AllowPlayerToJoinNoCheck(FString* SteamId) { NativeCall<void, FString*>(this, "UShooterCheatManager.AllowPlayerToJoinNoCheck", SteamId); }
    void RenameTribe(FString* TribeName, FString* NewName) { NativeCall<void, FString*, FString*>(this, "UShooterCheatManager.RenameTribe", TribeName, NewName); }
    void RenameTribeID(int TribeID, FString* NewName) { NativeCall<void, int, FString*>(this, "UShooterCheatManager.RenameTribeID", TribeID, NewName); }
    void RenamePlayer(FString* PlayerName, FString* NewName) { NativeCall<void, FString*, FString*>(this, "UShooterCheatManager.RenamePlayer", PlayerName, NewName); }
    void RenamePlayerId(int PlayerID, FString* NewName) { NativeCall<void, int, FString*>(this, "UShooterCheatManager.RenamePlayerId", PlayerID, NewName); }
    void DestroyActors(FString* ClassName) { NativeCall<void, FString*>(this, "UShooterCheatManager.DestroyActors", ClassName); }
    void DestroyWildDinoClasses(FString* ClassName) { NativeCall<void, FString*>(this, "UShooterCheatManager.DestroyWildDinoClasses", ClassName); }
    void SetGraphicsQuality(int val) { NativeCall<void, int>(this, "UShooterCheatManager.SetGraphicsQuality", val); }
    void SaveWorld() { NativeCall<void>(this, "UShooterCheatManager.SaveWorld"); }
    void StartSaveBackup() { NativeCall<void>(this, "UShooterCheatManager.StartSaveBackup"); }
    void DoExit() { NativeCall<void>(this, "UShooterCheatManager.DoExit"); }
    void OpenMap(FString* MapName) { NativeCall<void, FString*>(this, "UShooterCheatManager.OpenMap", MapName); }
    void DoRestartLevel() { NativeCall<void>(this, "UShooterCheatManager.DoRestartLevel"); }
    void SetGlobalPause(bool bIsPaused) { NativeCall<void, bool>(this, "UShooterCheatManager.SetGlobalPause", bIsPaused); }
    void DisallowPlayerToJoinNoCheck(FString* SteamId) { NativeCall<void, FString*>(this, "UShooterCheatManager.DisallowPlayerToJoinNoCheck", SteamId); }
    void CamZoomIn() { NativeCall<void>(this, "UShooterCheatManager.CamZoomIn"); }
    void CamZoomOut() { NativeCall<void>(this, "UShooterCheatManager.CamZoomOut"); }
    void OnToggleInGameMenu() { NativeCall<void>(this, "UShooterCheatManager.OnToggleInGameMenu"); }
    void GiveResources() { NativeCall<void>(this, "UShooterCheatManager.GiveResources"); }
    void GiveEngrams() { NativeCall<void>(this, "UShooterCheatManager.GiveEngrams"); }
    void GiveEngramsTekOnly() { NativeCall<void>(this, "UShooterCheatManager.GiveEngramsTekOnly"); }
    bool SetCreativeModeOnPawn(AShooterCharacter* Pawn, bool bCreativeMode) { return NativeCall<bool, AShooterCharacter*, bool>(this, "UShooterCheatManager.SetCreativeModeOnPawn", Pawn, bCreativeMode); }
    void GiveCreativeMode() { NativeCall<void>(this, "UShooterCheatManager.GiveCreativeMode"); }
    void GCM() { NativeCall<void>(this, "UShooterCheatManager.GCM"); }
    void DeepPockets() { NativeCall<void>(this, "UShooterCheatManager.DeepPockets"); }
    void InfiniteWeight() { NativeCall<void>(this, "UShooterCheatManager.InfiniteWeight"); }
    void GiveCreativeModeToTarget() { NativeCall<void>(this, "UShooterCheatManager.GiveCreativeModeToTarget"); }
    void GCMT() { NativeCall<void>(this, "UShooterCheatManager.GCMT"); }
    void GlobalObjectCount() { NativeCall<void>(this, "UShooterCheatManager.GlobalObjectCount"); }
    void GiveCreativeModeToPlayer(__int64 PlayerID) { NativeCall<void, __int64>(this, "UShooterCheatManager.GiveCreativeModeToPlayer", PlayerID); }
    void GCMP(__int64 PlayerID) { NativeCall<void, __int64>(this, "UShooterCheatManager.GCMP", PlayerID); }
    void ForceTribes(FString* PlayerName1, FString* PlayerName2, FString* NewTribeName) { NativeCall<void, FString*, FString*, FString*>(this, "UShooterCheatManager.ForceTribes", PlayerName1, PlayerName2, NewTribeName); }
    void ShowInGameMenu() { NativeCall<void>(this, "UShooterCheatManager.ShowInGameMenu"); }
    void AddExperienceToTarget(float HowMuch, bool fromTribeShare, bool bPreventSharingWithTribe) { NativeCall<void, float, bool, bool>(this, "UShooterCheatManager.AddExperienceToTarget", HowMuch, fromTribeShare, bPreventSharingWithTribe); }
    void AddExperience(float HowMuch, bool fromTribeShare, bool bPreventSharingWithTribe) { NativeCall<void, float, bool, bool>(this, "UShooterCheatManager.AddExperience", HowMuch, fromTribeShare, bPreventSharingWithTribe); }
    void LevelUp(FName statName, int numLevels) { NativeCall<void, FName, int>(this, "UShooterCheatManager.LevelUp", statName, numLevels); }
    void SetStatOnTarget(FName StatName, float value) { NativeCall<void, FName, float>(this, "UShooterCheatManager.SetStatOnTarget", StatName, value); }
    void LevelUpAOE(FName statName, float Radius, int numLevels) { NativeCall<void, FName, float, int>(this, "UShooterCheatManager.LevelUpAOE", statName, Radius, numLevels); }
    void LevelUpTarget(FName StatName, int NumLevels) { NativeCall<void, FName, int>(this, "UShooterCheatManager.LevelUpTarget", StatName, NumLevels); }
    void LevelUpInternal(APrimalCharacter* character, FName statName, int numLevels) { NativeCall<void, APrimalCharacter*, FName, int>(this, "UShooterCheatManager.LevelUpInternal", character, statName, numLevels); }
    void GiveExpToPlayer(__int64 PlayerID, float HowMuch, bool fromTribeShare, bool bPreventSharingWithTribe) { NativeCall<void, __int64, float, bool, bool>(this, "UShooterCheatManager.GiveExpToPlayer", PlayerID, HowMuch, fromTribeShare, bPreventSharingWithTribe); }
    void GiveTekEngramsTo(__int64 PlayerID, FName* blueprintPath) { NativeCall<void, __int64, FName*>(this, "UShooterCheatManager.GiveTekEngramsTo", PlayerID, blueprintPath); }
    void GiveExpToTarget(float HowMuch, bool fromTribeShare, bool bPreventSharingWithTribe) { NativeCall<void, float, bool, bool>(this, "UShooterCheatManager.GiveExpToTarget", HowMuch, fromTribeShare, bPreventSharingWithTribe); }
    void DebugMyTarget() { NativeCall<void>(this, "UShooterCheatManager.DebugMyTarget"); }
    void DebugMyTargetFromLocation(FVector* spectatorLocation, FRotator* rotator) { NativeCall<void, FVector*, FRotator*>(this, "UShooterCheatManager.DebugMyTargetFromLocation", spectatorLocation, rotator); }
    void DebugMyTargetPrint(AActor* actor) { NativeCall<void, AActor*>(this, "UShooterCheatManager.DebugMyTargetPrint", actor); }
    void DestroyMyTarget() { NativeCall<void>(this, "UShooterCheatManager.DestroyMyTarget"); }
    void SetMyTargetSleeping(bool bIsSleeping) { NativeCall<void, bool>(this, "UShooterCheatManager.SetMyTargetSleeping", bIsSleeping); }
    void SetTargetDinoColor(int ColorRegion, int ColorID) { NativeCall<void, int, int>(this, "UShooterCheatManager.SetTargetDinoColor", ColorRegion, ColorID); }
    void Kill() { NativeCall<void>(this, "UShooterCheatManager.Kill"); }
    void KillAOETribe(FName Category, float Radius, int TribeID) { NativeCall<void, FName, float, int>(this, "UShooterCheatManager.KillAOETribe", Category, Radius, TribeID); }
    void KillAOE(FName Category, float Radius) { NativeCall<void, FName, float>(this, "UShooterCheatManager.KillAOE", Category, Radius); }
    void Mission(FName CheatName, float Value) { NativeCall<void, FName, float>(this, "UShooterCheatManager.Mission", CheatName, Value); }
    void Dino(FName CheatName) { NativeCall<void, FName>(this, "UShooterCheatManager.Dino", CheatName); }
    void DinoSet(FName CheatName, float Value) { NativeCall<void, FName, float>(this, "UShooterCheatManager.DinoSet", CheatName, Value); }
    void SetNetworkTime(float NewTime) { NativeCall<void, float>(this, "UShooterCheatManager.SetNetworkTime", NewTime); }
    void SetDifficultyValue(float Value) { NativeCall<void, float>(this, "UShooterCheatManager.SetDifficultyValue", Value); }
    TArray<TSubclassOf<AMissionType>>* FuzzyMissionSearch(TArray<TSubclassOf<AMissionType>>* result, FString* MissionTag) { return NativeCall<TArray<TSubclassOf<AMissionType>>*, TArray<TSubclassOf<AMissionType>>*, FString*>(this, "UShooterCheatManager.FuzzyMissionSearch", result, MissionTag); }
    void StartMission(FName MissionTag) { NativeCall<void, FName>(this, "UShooterCheatManager.StartMission", MissionTag); }
    void ForceStartMission(FName MissionTag) { NativeCall<void, FName>(this, "UShooterCheatManager.ForceStartMission", MissionTag); }
    void LeaveMission() { NativeCall<void>(this, "UShooterCheatManager.LeaveMission"); }
    void CompleteMission() { NativeCall<void>(this, "UShooterCheatManager.CompleteMission"); }
    void DeactivateMission() { NativeCall<void>(this, "UShooterCheatManager.DeactivateMission"); }
    void SetActiveMissionDebugFlags(int DebugFlags) { NativeCall<void, int>(this, "UShooterCheatManager.SetActiveMissionDebugFlags", DebugFlags); }
    void ShowActiveMissions() { NativeCall<void>(this, "UShooterCheatManager.ShowActiveMissions"); }
    void KillPlayer(__int64 PlayerID) { NativeCall<void, __int64>(this, "UShooterCheatManager.KillPlayer", PlayerID); }
    void TeleportPlayerIDToMe(__int64 PlayerID) { NativeCall<void, __int64>(this, "UShooterCheatManager.TeleportPlayerIDToMe", PlayerID); }
    void TeleportPlayerNameToMe(FString* PlayerName) { NativeCall<void, FString*>(this, "UShooterCheatManager.TeleportPlayerNameToMe", PlayerName); }
    void TeleportToPlayer(__int64 PlayerID) { NativeCall<void, __int64>(this, "UShooterCheatManager.TeleportToPlayer", PlayerID); }
    void TeleportToPlayerName(FString* PlayerName) { NativeCall<void, FString*>(this, "UShooterCheatManager.TeleportToPlayerName", PlayerName); }
    void TPName(FString* PlayerName) { NativeCall<void, FString*>(this, "UShooterCheatManager.TPName", PlayerName); }
    void DestroyTribePlayers() { NativeCall<void>(this, "UShooterCheatManager.DestroyTribePlayers"); }
    void DestroyTribeIdPlayers(int TribeTeamID) { NativeCall<void, int>(this, "UShooterCheatManager.DestroyTribeIdPlayers", TribeTeamID); }
    void DestroyTribeDinos() { NativeCall<void>(this, "UShooterCheatManager.DestroyTribeDinos"); }
    void DestroyTribeIdDinos(int TribeTeamID) { NativeCall<void, int>(this, "UShooterCheatManager.DestroyTribeIdDinos", TribeTeamID); }
    void DestroyAllTames() { NativeCall<void>(this, "UShooterCheatManager.DestroyAllTames"); }
    void DestroyTribeStructures() { NativeCall<void>(this, "UShooterCheatManager.DestroyTribeStructures"); }
    void DestroyTribeIdStructures(int TribeTeamID) { NativeCall<void, int>(this, "UShooterCheatManager.DestroyTribeIdStructures", TribeTeamID); }
    void DestroyTribeId(int TribeTeamID) { NativeCall<void, int>(this, "UShooterCheatManager.DestroyTribeId", TribeTeamID); }
    void DestroyTribeStructuresLessThan(int TribeTeamID, int Connections, bool includeContainers) { NativeCall<void, int, int, bool>(this, "UShooterCheatManager.DestroyTribeStructuresLessThan", TribeTeamID, Connections, includeContainers); }
    void TribeMessage(int TribeTeamID, FString Message) { NativeCall<void, int, FString>(this, "UShooterCheatManager.TribeMessage", TribeTeamID, Message); }
    void ForcePlayerToJoinTargetTribe(__int64 PlayerID) { NativeCall<void, __int64>(this, "UShooterCheatManager.ForcePlayerToJoinTargetTribe", PlayerID); }
    void ForcePoop() { NativeCall<void>(this, "UShooterCheatManager.ForcePoop"); }
    void ForceJoinTribe() { NativeCall<void>(this, "UShooterCheatManager.ForceJoinTribe"); }
    void ForcePlayerToJoinTribe(__int64 PlayerID, FString TribeName) { NativeCall<void, __int64, FString>(this, "UShooterCheatManager.ForcePlayerToJoinTribe", PlayerID, TribeName); }
    void ForcePlayerToJoinTribeId(__int64 PlayerID, int TribeTeamID) { NativeCall<void, __int64, int>(this, "UShooterCheatManager.ForcePlayerToJoinTribeId", PlayerID, TribeTeamID); }
    void JoinTribe(__int64 PlayerID, int TribeTeamID) { NativeCall<void, __int64, int>(this, "UShooterCheatManager.JoinTribe", PlayerID, TribeTeamID); }
    void SpawnActor(FString* blueprintPath, float spawnDistance, float spawnYOffset, float ZOffset) { NativeCall<void, FString*, float, float, float>(this, "UShooterCheatManager.SpawnActor", blueprintPath, spawnDistance, spawnYOffset, ZOffset); }
    void SpawnActorTamed(FString* blueprintPath, float spawnDistance, float spawnYOffset, float ZOffset) { NativeCall<void, FString*, float, float, float>(this, "UShooterCheatManager.SpawnActorTamed", blueprintPath, spawnDistance, spawnYOffset, ZOffset); }
    void SpawnDino(FString* blueprintPath, float spawnDistance, float spawnYOffset, float ZOffset, int DinoLevel) { NativeCall<void, FString*, float, float, float, int>(this, "UShooterCheatManager.SpawnDino", blueprintPath, spawnDistance, spawnYOffset, ZOffset, DinoLevel); }
    APrimalDinoCharacter* SpawnSetupDinoInternal(FDinoSetup* DinoSetup, FRotator* SpawnRot) { return NativeCall<APrimalDinoCharacter*, FDinoSetup*, FRotator*>(this, "UShooterCheatManager.SpawnSetupDinoInternal", DinoSetup, SpawnRot); }
    void SpawnSetupDino(FString* DinoBlueprintPath, FString* SaddleBlueprintPath, float SaddleQuality, int DinoLevel, FString* DinoStats, float SpawnDistance, float YOffset, float ZOffset) { NativeCall<void, FString*, FString*, float, int, FString*, float, float, float>(this, "UShooterCheatManager.SpawnSetupDino", DinoBlueprintPath, SaddleBlueprintPath, SaddleQuality, DinoLevel, DinoStats, SpawnDistance, YOffset, ZOffset); }
    void SpawnExactDino(FString* DinoBlueprintPath, FString* SaddleBlueprintPath, float SaddleQuality, int BaseLevel, int ExtraLevels, FString* BaseStats, FString* AddedStats, FString* DinoName, char Cloned, char Neutered, FString* TamedOn, FString* UploadedFrom, FString* ImprinterName, int ImprinterPlayerID, float ImprintQuality, FString* Colors, __int64 DinoID, __int64 Exp, float SpawnDistance, float YOffset, float ZOffset) { NativeCall<void, FString*, FString*, float, int, int, FString*, FString*, FString*, char, char, FString*, FString*, FString*, int, float, FString*, __int64, __int64, float, float, float>(this, "UShooterCheatManager.SpawnExactDino", DinoBlueprintPath, SaddleBlueprintPath, SaddleQuality, BaseLevel, ExtraLevels, BaseStats, AddedStats, DinoName, Cloned, Neutered, TamedOn, UploadedFrom, ImprinterName, ImprinterPlayerID, ImprintQuality, Colors, DinoID, Exp, SpawnDistance, YOffset, ZOffset); }
    void DumpDinoStats() { NativeCall<void>(this, "UShooterCheatManager.DumpDinoStats"); }
    AActor* DoSummon(FString* ClassName) { return NativeCall<AActor*, FString*>(this, "UShooterCheatManager.DoSummon", ClassName); }
    void Summon(FString* ClassName) { NativeCall<void, FString*>(this, "UShooterCheatManager.Summon", ClassName); }
    void SummonTamed(FString* ClassName) { NativeCall<void, FString*>(this, "UShooterCheatManager.SummonTamed", ClassName); }
    void ForceGiveBuff(FName* BuffBlueprintPath, bool bEnable) { NativeCall<void, FName*, bool>(this, "UShooterCheatManager.ForceGiveBuff", BuffBlueprintPath, bEnable); }
    void SDF(FName* DinoBlueprintPath, bool bIsTamed) { NativeCall<void, FName*, bool>(this, "UShooterCheatManager.SDF", DinoBlueprintPath, bIsTamed); }
    void SpawnActorSpread(FString* blueprintPath, float spawnDistance, float spawnYOffset, float ZOffset, int NumberActors, float SpreadAmount) { NativeCall<void, FString*, float, float, float, int, float>(this, "UShooterCheatManager.SpawnActorSpread", blueprintPath, spawnDistance, spawnYOffset, ZOffset, NumberActors, SpreadAmount); }
    void SpawnActorSpreadTamed(FString* blueprintPath, float spawnDistance, float spawnYOffset, float ZOffset, int NumberActors, float SpreadAmount) { NativeCall<void, FString*, float, float, float, int, float>(this, "UShooterCheatManager.SpawnActorSpreadTamed", blueprintPath, spawnDistance, spawnYOffset, ZOffset, NumberActors, SpreadAmount); }
    void RainDinosHelper(TArray<FString>* dinoRefs, int NumberActors, float SpreadAmount, float ZOffset) { NativeCall<void, TArray<FString>*, int, float, float>(this, "UShooterCheatManager.RainDinosHelper", dinoRefs, NumberActors, SpreadAmount, ZOffset); }
    void RainCritters(int NumberActors, float SpreadAmount, float ZOffset) { NativeCall<void, int, float, float>(this, "UShooterCheatManager.RainCritters", NumberActors, SpreadAmount, ZOffset); }
    void RainDinos(int NumberActors, float SpreadAmount, float ZOffset) { NativeCall<void, int, float, float>(this, "UShooterCheatManager.RainDinos", NumberActors, SpreadAmount, ZOffset); }
    void RainDanger(int NumberActors, float SpreadAmount, float ZOffset) { NativeCall<void, int, float, float>(this, "UShooterCheatManager.RainDanger", NumberActors, SpreadAmount, ZOffset); }
    void LeaveMeAlone() { NativeCall<void>(this, "UShooterCheatManager.LeaveMeAlone"); }
    void InfiniteStats() { NativeCall<void>(this, "UShooterCheatManager.InfiniteStats"); }
    void SetInfiniteStats(bool bInfinite) { NativeCall<void, bool>(this, "UShooterCheatManager.SetInfiniteStats", bInfinite); }
    void GiveInfiniteStatsToTarget() { NativeCall<void>(this, "UShooterCheatManager.GiveInfiniteStatsToTarget"); }
    void RefillStats() { NativeCall<void>(this, "UShooterCheatManager.RefillStats"); }
    void ToggleHud() { NativeCall<void>(this, "UShooterCheatManager.ToggleHud"); }
    void EnableCheats(FString pass) { NativeCall<void, FString>(this, "UShooterCheatManager.EnableCheats", pass); }
    void ToggleGun() { NativeCall<void>(this, "UShooterCheatManager.ToggleGun"); }
    void ToggleDamageNumbers() { NativeCall<void>(this, "UShooterCheatManager.ToggleDamageNumbers"); }
    void ToggleDamageLogging() { NativeCall<void>(this, "UShooterCheatManager.ToggleDamageLogging"); }
    void SetGodMode(bool bEnable) { NativeCall<void, bool>(this, "UShooterCheatManager.SetGodMode", bEnable); }
    void BanPlayer(FString PlayerSteamName) { NativeCall<void, FString>(this, "UShooterCheatManager.BanPlayer", PlayerSteamName); }
    void UnbanPlayer(FString PlayerSteamName) { NativeCall<void, FString>(this, "UShooterCheatManager.UnbanPlayer", PlayerSteamName); }
    void EnableSpectator() { NativeCall<void>(this, "UShooterCheatManager.EnableSpectator"); }
    void DisableSpectator() { NativeCall<void>(this, "UShooterCheatManager.DisableSpectator"); }
    void KickPlayer(FString PlayerSteamName) { NativeCall<void, FString>(this, "UShooterCheatManager.KickPlayer", PlayerSteamName); }
    void Suicide() { NativeCall<void>(this, "UShooterCheatManager.Suicide"); }
    void ForceTame() { NativeCall<void>(this, "UShooterCheatManager.ForceTame"); }
    void ForceTameAOE(float Radius) { NativeCall<void, float>(this, "UShooterCheatManager.ForceTameAOE", Radius); }
    void SetImprintQuality(float ImprintQuality) { NativeCall<void, float>(this, "UShooterCheatManager.SetImprintQuality", ImprintQuality); }
    void SetTamingEffectivenessModifier(float TamingEffectiveness) { NativeCall<void, float>(this, "UShooterCheatManager.SetTamingEffectivenessModifier", TamingEffectiveness); }
    void StartNearestHorde(FName HordeType, int DifficultyLevel) { NativeCall<void, FName, int>(this, "UShooterCheatManager.StartNearestHorde", HordeType, DifficultyLevel); }
    void ListActiveHordeEvents() { NativeCall<void>(this, "UShooterCheatManager.ListActiveHordeEvents"); }
    void TeleportToActiveHorde(int EventIndex) { NativeCall<void, int>(this, "UShooterCheatManager.TeleportToActiveHorde", EventIndex); }
    void SetImprintedPlayer(FString NewImprinterName, int NewImprinterPlayerDataID) { NativeCall<void, FString, int>(this, "UShooterCheatManager.SetImprintedPlayer", NewImprinterName, NewImprinterPlayerDataID); }
    void TransferImprints(int oldPlayerId, int newPlayerId, FString NewImprinterName) { NativeCall<void, int, int, FString>(this, "UShooterCheatManager.TransferImprints", oldPlayerId, newPlayerId, NewImprinterName); }
    void DoTame() { NativeCall<void>(this, "UShooterCheatManager.DoTame"); }
    void GiveToMe() { NativeCall<void>(this, "UShooterCheatManager.GiveToMe"); }
    void GiveToMeAOE(float Radius) { NativeCall<void, float>(this, "UShooterCheatManager.GiveToMeAOE", Radius); }
    void GiveAllStructure() { NativeCall<void>(this, "UShooterCheatManager.GiveAllStructure"); }
    void SetTargetPlayerBodyVal(int BodyValIndex, float BodyVal) { NativeCall<void, int, float>(this, "UShooterCheatManager.SetTargetPlayerBodyVal", BodyValIndex, BodyVal); }
    void SetTargetPlayerColorVal(int ColorValIndex, float ColorVal) { NativeCall<void, int, float>(this, "UShooterCheatManager.SetTargetPlayerColorVal", ColorValIndex, ColorVal); }
    void SetBabyAge(float AgeValue) { NativeCall<void, float>(this, "UShooterCheatManager.SetBabyAge", AgeValue); }
    void ListPlayers() { NativeCall<void>(this, "UShooterCheatManager.ListPlayers"); }
    void GetChat() { NativeCall<void>(this, "UShooterCheatManager.GetChat"); }
    void GetGameLog() { NativeCall<void>(this, "UShooterCheatManager.GetGameLog"); }
    void EnemyInVisible(bool Invisible) { NativeCall<void, bool>(this, "UShooterCheatManager.EnemyInVisible", Invisible); }
    void ShowTutorial(int TutorialIndex, bool bForceDisplay) { NativeCall<void, int, bool>(this, "UShooterCheatManager.ShowTutorial", TutorialIndex, bForceDisplay); }
    void HideTutorial(int TutorialInde) { NativeCall<void, int>(this, "UShooterCheatManager.HideTutorial", TutorialInde); }
    void ClearTutorials() { NativeCall<void>(this, "UShooterCheatManager.ClearTutorials"); }
    void TestSteamRefreshItems() { NativeCall<void>(this, "UShooterCheatManager.TestSteamRefreshItems"); }
    void AddItemToAllClustersInventory(FString UserId, int MasterIndexNum) { NativeCall<void, FString, int>(this, "UShooterCheatManager.AddItemToAllClustersInventory", UserId, MasterIndexNum); }
    void GiveItemNum(int masterIndexNum, int quantityOverride, float qualityOverride, bool bForceBlueprint) { NativeCall<void, int, int, float, bool>(this, "UShooterCheatManager.GiveItemNum", masterIndexNum, quantityOverride, qualityOverride, bForceBlueprint); }
    void GiveItem(FString* blueprintPath, int quantityOverride, float qualityOverride, bool bForceBlueprint) { NativeCall<void, FString*, int, float, bool>(this, "UShooterCheatManager.GiveItem", blueprintPath, quantityOverride, qualityOverride, bForceBlueprint); }
    static void GiveAllItemsInSet(AShooterPlayerController* Controller, TArray<FItemCount>* Items) { NativeCall<void, AShooterPlayerController*, TArray<FItemCount>*>(nullptr, "UShooterCheatManager.GiveAllItemsInSet", Controller, Items); }
    static float QualityNameToFloat(FName QualityName) { return NativeCall<float, FName>(nullptr, "UShooterCheatManager.QualityNameToFloat", QualityName); }
    void GiveArmorSet(FName Tier, FName QualityName) { NativeCall<void, FName, FName>(this, "UShooterCheatManager.GiveArmorSet", Tier, QualityName); }
    void GiveWeaponSet(FName Tier, FName QualityName) { NativeCall<void, FName, FName>(this, "UShooterCheatManager.GiveWeaponSet", Tier, QualityName); }
    void GiveItemSet(FName Tier) { NativeCall<void, FName>(this, "UShooterCheatManager.GiveItemSet", Tier); }
    void GMComp(int level) { NativeCall<void, int>(this, "UShooterCheatManager.GMComp", level); }
    void GiveDinoSet(FName Tier, int NumDinos) { NativeCall<void, FName, int>(this, "UShooterCheatManager.GiveDinoSet", Tier, NumDinos); }
    void GiveDinoSet() { NativeCall<void>(this, "UShooterCheatManager.GiveDinoSet"); }
    void AddEquipmentDurability(const float durability) { NativeCall<void, const float>(this, "UShooterCheatManager.AddEquipmentDurability", durability); }
    void GFI(FName* blueprintPath, int quantityOverride, float qualityOverride, bool bForceBlueprint) { NativeCall<void, FName*, int, float, bool>(this, "UShooterCheatManager.GFI", blueprintPath, quantityOverride, qualityOverride, bForceBlueprint); }
    void GiveItemToPlayer(int playerID, FString* blueprintPath, int quantityOverride, float qualityOverride, bool bForceBlueprint) { NativeCall<void, int, FString*, int, float, bool>(this, "UShooterCheatManager.GiveItemToPlayer", playerID, blueprintPath, quantityOverride, qualityOverride, bForceBlueprint); }
    void GiveItemNumToPlayer(int playerID, int masterIndexNum, int quantityOverride, float qualityOverride, bool bForceBlueprint) { NativeCall<void, int, int, int, float, bool>(this, "UShooterCheatManager.GiveItemNumToPlayer", playerID, masterIndexNum, quantityOverride, qualityOverride, bForceBlueprint); }
    void ClearPlayerInventory(int playerID, bool bClearInventory, bool bClearSlotItems, bool bClearEquippedItems) { NativeCall<void, int, bool, bool, bool>(this, "UShooterCheatManager.ClearPlayerInventory", playerID, bClearInventory, bClearSlotItems, bClearEquippedItems); }
    void DoTestingThing() { NativeCall<void>(this, "UShooterCheatManager.DoTestingThing"); }
    void DoHang() { NativeCall<void>(this, "UShooterCheatManager.DoHang"); }
    void SetMessageOfTheDay(FString* Message) { NativeCall<void, FString*>(this, "UShooterCheatManager.SetMessageOfTheDay", Message); }
    void ShowMessageOfTheDay() { NativeCall<void>(this, "UShooterCheatManager.ShowMessageOfTheDay"); }
    void ReportSpawnManagers() { NativeCall<void>(this, "UShooterCheatManager.ReportSpawnManagers"); }
    void HibernationReport(FString* ClassName) { NativeCall<void, FString*>(this, "UShooterCheatManager.HibernationReport", ClassName); }
    void HiWarp(FString* ClassName, int Index) { NativeCall<void, FString*, int>(this, "UShooterCheatManager.HiWarp", ClassName, Index); }
    void ReportLeastSpawnManagers() { NativeCall<void>(this, "UShooterCheatManager.ReportLeastSpawnManagers"); }
    void DestroyAllEnemies() { NativeCall<void>(this, "UShooterCheatManager.DestroyAllEnemies"); }
    void DestroyWildDinos() { NativeCall<void>(this, "UShooterCheatManager.DestroyWildDinos"); }
    void DestroyStructures() { NativeCall<void>(this, "UShooterCheatManager.DestroyStructures"); }
    void SetPlayerPos(float X, float Y, float Z) { NativeCall<void, float, float, float>(this, "UShooterCheatManager.SetPlayerPos", X, Y, Z); }
    void PrintActorLocation(FString* ActorName) { NativeCall<void, FString*>(this, "UShooterCheatManager.PrintActorLocation", ActorName); }
    void TeleportToActorLocation(FString* ActorName) { NativeCall<void, FString*>(this, "UShooterCheatManager.TeleportToActorLocation", ActorName); }
    void SPI(float X, float Y, float Z, float Yaw, float Pitch) { NativeCall<void, float, float, float, float, float>(this, "UShooterCheatManager.SPI", X, Y, Z, Yaw, Pitch); }
    void TP(FString LocationName) { NativeCall<void, FString>(this, "UShooterCheatManager.TP", LocationName); }
    void TPCoords(float lat, float lon, float z) { NativeCall<void, float, float, float>(this, "UShooterCheatManager.TPCoords", lat, lon, z); }
    void ToggleLocation() { NativeCall<void>(this, "UShooterCheatManager.ToggleLocation"); }
    void SaveWorldDisableTransfer() { NativeCall<void>(this, "UShooterCheatManager.SaveWorldDisableTransfer"); }
    void SetTimeOfDay(FString* timeString) { NativeCall<void, FString*>(this, "UShooterCheatManager.SetTimeOfDay", timeString); }
    void WhatIsMyTarget() { NativeCall<void>(this, "UShooterCheatManager.WhatIsMyTarget"); }
    void IsUndermesh(const float debugDrawSeconds) { NativeCall<void, const float>(this, "UShooterCheatManager.IsUndermesh", debugDrawSeconds); }
    void SetDebugMeleeAttacks(bool bDebugMelee, const float drawDuration) { NativeCall<void, bool, const float>(this, "UShooterCheatManager.SetDebugMeleeAttacks", bDebugMelee, drawDuration); }
    void MoveTargetTo(float x, float y, float z) { NativeCall<void, float, float, float>(this, "UShooterCheatManager.MoveTargetTo", x, y, z); }
    void ServerChatTo(FString* SteamID, FString* MessageText) { NativeCall<void, FString*, FString*>(this, "UShooterCheatManager.ServerChatTo", SteamID, MessageText); }
    void ServerChatToPlayer(FString* PlayerName, FString* MessageText) { NativeCall<void, FString*, FString*>(this, "UShooterCheatManager.ServerChatToPlayer", PlayerName, MessageText); }
    void ServerChat(FString* MessageText) { NativeCall<void, FString*>(this, "UShooterCheatManager.ServerChat", MessageText); }
    void SetChatLogMaxAgeInDays(int NumDays) { NativeCall<void, int>(this, "UShooterCheatManager.SetChatLogMaxAgeInDays", NumDays); }
    void ForceUpdateDynamicConfig() { NativeCall<void>(this, "UShooterCheatManager.ForceUpdateDynamicConfig"); }
    void DumpAssetProperties(FString* Asset) { NativeCall<void, FString*>(this, "UShooterCheatManager.DumpAssetProperties", Asset); }
    void ResetLiveTuningOverloads() { NativeCall<void>(this, "UShooterCheatManager.ResetLiveTuningOverloads"); }
    AShooterPlayerController* FindPlayerControllerFromPlayerID(__int64 PlayerID) { return NativeCall<AShooterPlayerController*, __int64>(this, "UShooterCheatManager.FindPlayerControllerFromPlayerID", PlayerID); }
    void GameCommand(FString* TheCommand) { NativeCall<void, FString*>(this, "UShooterCheatManager.GameCommand", TheCommand); }
    void ScriptCommand(FString* commandString) { NativeCall<void, FString*>(this, "UShooterCheatManager.ScriptCommand", commandString); }
    void PlayerCommand(FString* TheCommand) { NativeCall<void, FString*>(this, "UShooterCheatManager.PlayerCommand", TheCommand); }
    void MakeTribeAdmin() { NativeCall<void>(this, "UShooterCheatManager.MakeTribeAdmin"); }
    void RemoveTribeAdmin() { NativeCall<void>(this, "UShooterCheatManager.RemoveTribeAdmin"); }
    void MakeTribeFounder() { NativeCall<void>(this, "UShooterCheatManager.MakeTribeFounder"); }
    void GiveExplorerNote(int NoteIndex) { NativeCall<void, int>(this, "UShooterCheatManager.GiveExplorerNote", NoteIndex); }
    void GiveAllExplorerNotes() { NativeCall<void>(this, "UShooterCheatManager.GiveAllExplorerNotes"); }
    void VisualizeClass(FString* ClassIn, int MaxTotal) { NativeCall<void, FString*, int>(this, "UShooterCheatManager.VisualizeClass", ClassIn, MaxTotal); }
    void UnlockEngram(FString* ItemClassName) { NativeCall<void, FString*>(this, "UShooterCheatManager.UnlockEngram", ItemClassName); }
    void SetHeadHairPercent(float thePercent) { NativeCall<void, float>(this, "UShooterCheatManager.SetHeadHairPercent", thePercent); }
    void SetFacialHairPercent(float thePercent) { NativeCall<void, float>(this, "UShooterCheatManager.SetFacialHairPercent", thePercent); }
    void SetHeadHairstyle(int hairStyleIndex) { NativeCall<void, int>(this, "UShooterCheatManager.SetHeadHairstyle", hairStyleIndex); }
    void SetFacialHairstyle(int hairStyleIndex) { NativeCall<void, int>(this, "UShooterCheatManager.SetFacialHairstyle", hairStyleIndex); }
    void PrintMessageOut(FString* Msg) { NativeCall<void, FString*>(this, "UShooterCheatManager.PrintMessageOut", Msg); }
    void GetTribeIdPlayerList(int TribeID) { NativeCall<void, int>(this, "UShooterCheatManager.GetTribeIdPlayerList", TribeID); }
    void GetSteamIDForPlayerID(int PlayerID) { NativeCall<void, int>(this, "UShooterCheatManager.GetSteamIDForPlayerID", PlayerID); }
    void GetPlayerIDForSteamID(int SteamID) { NativeCall<void, int>(this, "UShooterCheatManager.GetPlayerIDForSteamID", SteamID); }
    void SetShowAllPlayers(bool bEnable) { NativeCall<void, bool>(this, "UShooterCheatManager.SetShowAllPlayers", bEnable); }
    void SAP() { NativeCall<void>(this, "UShooterCheatManager.SAP"); }
    void TribeStructureAudit(int TribeTeamID) { NativeCall<void, int>(this, "UShooterCheatManager.TribeStructureAudit", TribeTeamID); }
    void TribeDinoAudit(int TribeTeamID) { NativeCall<void, int>(this, "UShooterCheatManager.TribeDinoAudit", TribeTeamID); }
    void psc(FString* command) { NativeCall<void, FString*>(this, "UShooterCheatManager.psc", command); }
    void DetachChar() { NativeCall<void>(this, "UShooterCheatManager.DetachChar"); }
    void VerifyTransferInventory() { NativeCall<void>(this, "UShooterCheatManager.VerifyTransferInventory"); }
    void HatchEgg() { NativeCall<void>(this, "UShooterCheatManager.HatchEgg"); }
    void DefeatBoss(int playerID, FName bossName, char difficulty) { NativeCall<void, int, FName, char>(this, "UShooterCheatManager.DefeatBoss", playerID, bossName, difficulty); }
    void LvlUp(__int64 PlayerID, __int16 Level) { NativeCall<void, __int64, __int16>(this, "UShooterCheatManager.LvlUp", PlayerID, Level); }
    void LessThan(int TribeTeamID, int Connections, bool includeContainers) { NativeCall<void, int, int, bool>(this, "UShooterCheatManager.LessThan", TribeTeamID, Connections, includeContainers); }
    void SetInstantHarvest(bool bEnable) { NativeCall<void, bool>(this, "UShooterCheatManager.SetInstantHarvest", bEnable); }
    void DestroyFoliage(float Radius) { NativeCall<void, float>(this, "UShooterCheatManager.DestroyFoliage", Radius); }
    void RegrowFoliage(float Radius) { NativeCall<void, float>(this, "UShooterCheatManager.RegrowFoliage", Radius); }
    void ToggleLowGravSpin() { NativeCall<void>(this, "UShooterCheatManager.ToggleLowGravSpin"); }
    void ForceCheckInMesh() { NativeCall<void>(this, "UShooterCheatManager.ForceCheckInMesh"); }
    void ForceEnableMeshCheckingOnMe(bool bEnableChecking) { NativeCall<void, bool>(this, "UShooterCheatManager.ForceEnableMeshCheckingOnMe", bEnableChecking); }
    void SetPlayerLevel(__int64 PlayerID, __int16 Level) { NativeCall<void, __int64, __int16>(this, "UShooterCheatManager.SetPlayerLevel", PlayerID, Level); }
    void SendDataDogMetric(FString msg) { NativeCall<void, FString>(this, "UShooterCheatManager.SendDataDogMetric", msg); }
    void MaxAscend(int playerID) { NativeCall<void, int>(this, "UShooterCheatManager.MaxAscend", playerID); }
    void DefeatAllBosses(int playerID) { NativeCall<void, int>(this, "UShooterCheatManager.DefeatAllBosses", playerID); }
    void ReassertColorization() { NativeCall<void>(this, "UShooterCheatManager.ReassertColorization"); }
    void AddHexagons(float HowMuch) { NativeCall<void, float>(this, "UShooterCheatManager.AddHexagons", HowMuch); }
    void DebugAllowVRMissionTeleport() { NativeCall<void>(this, "UShooterCheatManager.DebugAllowVRMissionTeleport"); }
    void ToggleClawStepping() { NativeCall<void>(this, "UShooterCheatManager.ToggleClawStepping"); }
    void God() { NativeCall<void>(this, "UShooterCheatManager.God"); }
    void DupeLastItem() { NativeCall<void>(this, "UShooterCheatManager.DupeLastItem"); }
    void ForceCompleteActiveMission(FString* MissionStateSimValues) { NativeCall<void, FString*>(this, "UShooterCheatManager.ForceCompleteActiveMission", MissionStateSimValues); }
    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "UShooterCheatManager.StaticClass"); }
    static void StaticRegisterNativesUShooterCheatManager() { NativeCall<void>(nullptr, "UShooterCheatManager.StaticRegisterNativesUShooterCheatManager"); }
    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "UShooterCheatManager.GetPrivateStaticClass", Package); }
};
 
struct UPlayer : UObject
{
    APlayerController * PlayerControllerField() { return *GetNativePointerField<APlayerController**>(this, "UPlayer.PlayerController"); }
    int& CurrentNetSpeedField() { return *GetNativePointerField<int*>(this, "UPlayer.CurrentNetSpeed"); }
    int& ConfiguredInternetSpeedField() { return *GetNativePointerField<int*>(this, "UPlayer.ConfiguredInternetSpeed"); }
    int& ConfiguredLanSpeedField() { return *GetNativePointerField<int*>(this, "UPlayer.ConfiguredLanSpeed"); }
    unsigned __int64& TransferringPlayerDataIdField() { return *GetNativePointerField<unsigned __int64*>(this, "UPlayer.TransferringPlayerDataId"); }
 
    // Functions
 
    void SwitchController(APlayerController * PC) { NativeCall<void, APlayerController*>(this, "UPlayer.SwitchController", PC); }
};
 
struct UNetConnection : UPlayer
{
    FString& ClientGivenIPField() { return *GetNativePointerField<FString*>(this, "UNetConnection.ClientGivenIP"); }
    uint64 BattlEye_GetAddrAsInt() { return NativeCall<uint64>(this, "UNetConnection.BattlEye_GetAddrAsInt"); }
};
 
struct APlayerState : AInfo
{
    float& ScoreField() { return *GetNativePointerField<float*>(this, "APlayerState.Score"); }
    char& PingField() { return *GetNativePointerField<char*>(this, "APlayerState.Ping"); }
    FString& PlayerNameField() { return *GetNativePointerField<FString*>(this, "APlayerState.PlayerName"); }
    FString& OldNameField() { return *GetNativePointerField<FString*>(this, "APlayerState.OldName"); }
    int& PlayerIdField() { return *GetNativePointerField<int*>(this, "APlayerState.PlayerId"); }
    int& StartTimeField() { return *GetNativePointerField<int*>(this, "APlayerState.StartTime"); }
    float& ExactPingField() { return *GetNativePointerField<float*>(this, "APlayerState.ExactPing"); }
    FString& SavedNetworkAddressField() { return *GetNativePointerField<FString*>(this, "APlayerState.SavedNetworkAddress"); }
    FUniqueNetIdRepl& UniqueIdField() { return *GetNativePointerField<FUniqueNetIdRepl*>(this, "APlayerState.UniqueId"); }
    FName& SessionNameField() { return *GetNativePointerField<FName*>(this, "APlayerState.SessionName"); }
    char& CurPingBucketField() { return *GetNativePointerField<char*>(this, "APlayerState.CurPingBucket"); }
    float& CurPingBucketTimestampField() { return *GetNativePointerField<float*>(this, "APlayerState.CurPingBucketTimestamp"); }
 
    // Bit fields
 
    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" }; }
 
    // Functions
 
    UField* StaticClass() { return NativeCall<UField*>(this, "APlayerState.StaticClass"); }
    void UpdatePing(float InPing) { NativeCall<void, float>(this, "APlayerState.UpdatePing", InPing); }
    void RecalculateAvgPing() { NativeCall<void>(this, "APlayerState.RecalculateAvgPing"); }
    void OverrideWith(APlayerState* PlayerState) { NativeCall<void, APlayerState*>(this, "APlayerState.OverrideWith", PlayerState); }
    void CopyProperties(APlayerState* PlayerState) { NativeCall<void, APlayerState*>(this, "APlayerState.CopyProperties", PlayerState); }
    void PostInitializeComponents() { NativeCall<void>(this, "APlayerState.PostInitializeComponents"); }
    void ClientInitialize(AController* C) { NativeCall<void, AController*>(this, "APlayerState.ClientInitialize", C); }
    void OnRep_PlayerName() { NativeCall<void>(this, "APlayerState.OnRep_PlayerName"); }
    void OnRep_bIsInactive() { NativeCall<void>(this, "APlayerState.OnRep_bIsInactive"); }
    bool ShouldBroadCastWelcomeMessage(bool bExiting) { return NativeCall<bool, bool>(this, "APlayerState.ShouldBroadCastWelcomeMessage", bExiting); }
    void Destroyed() { NativeCall<void>(this, "APlayerState.Destroyed"); }
    void Reset() { NativeCall<void>(this, "APlayerState.Reset"); }
    FString* GetHumanReadableName(FString* result) { return NativeCall<FString*, FString*>(this, "APlayerState.GetHumanReadableName", result); }
    void SetPlayerName(FString* S) { NativeCall<void, FString*>(this, "APlayerState.SetPlayerName", S); }
    void OnRep_UniqueId() { NativeCall<void>(this, "APlayerState.OnRep_UniqueId"); }
    void SetUniqueId(TSharedPtr<FUniqueNetId, 0>* InUniqueId) { NativeCall<void, TSharedPtr<FUniqueNetId, 0>*>(this, "APlayerState.SetUniqueId", InUniqueId); }
    void RegisterPlayerWithSession(bool bWasFromInvite) { NativeCall<void, bool>(this, "APlayerState.RegisterPlayerWithSession", bWasFromInvite); }
    APlayerState* Duplicate() { return NativeCall<APlayerState*>(this, "APlayerState.Duplicate"); }
    void SeamlessTravelTo(APlayerState* NewPlayerState) { NativeCall<void, APlayerState*>(this, "APlayerState.SeamlessTravelTo", NewPlayerState); }
    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "APlayerState.GetLifetimeReplicatedProps", OutLifetimeProps); }
    static void StaticRegisterNativesAPlayerState() { NativeCall<void>(nullptr, "APlayerState.StaticRegisterNativesAPlayerState"); }
};
 
struct AShooterPlayerState : APlayerState
{
    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<char, 10> DefaultItemSlotEngramsField() { return {this, "AShooterPlayerState.DefaultItemSlotEngrams"}; }
    FTribeData * MyTribeDataField() { return GetNativePointerField<FTribeData*>(this, "AShooterPlayerState.MyTribeData"); }
    FTribeData * LastTribeInviteDataField() { return GetNativePointerField<FTribeData*>(this, "AShooterPlayerState.LastTribeInviteData"); }
    TArray<FSpawnPointInfo> & CachedSpawnPointInfosField() { return *GetNativePointerField<TArray<FSpawnPointInfo>*>(this, "AShooterPlayerState.CachedSpawnPointInfos"); }
    int& TotalEngramPointsField() { return *GetNativePointerField<int*>(this, "AShooterPlayerState.TotalEngramPoints"); }
    int& FreeEngramPointsField() { return *GetNativePointerField<int*>(this, "AShooterPlayerState.FreeEngramPoints"); }
    TArray<TSubclassOf<UPrimalItem>> & EngramItemBlueprintsField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalItem>>*>(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"); }
    long double& LastFlexPipeRefreshConnectionsNetworkTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerState.LastFlexPipeRefreshConnectionsNetworkTime"); }
    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& LastTribeRequestTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerState.LastTribeRequestTime"); }
 
    // Bit fields
 
    BitFieldValue<bool, unsigned __int32> bQuitter() { return { this, "AShooterPlayerState.bQuitter" }; }
 
    // Functions
 
    static UClass * StaticClass() { return NativeCall<UClass*>(nullptr, "AShooterPlayerState.StaticClass"); }
    void Reset() { NativeCall<void>(this, "AShooterPlayerState.Reset"); }
    void UnregisterPlayerWithSession() { NativeCall<void>(this, "AShooterPlayerState.UnregisterPlayerWithSession"); }
    void ClientInitialize(AController * InController) { NativeCall<void, AController*>(this, "AShooterPlayerState.ClientInitialize", InController); }
    void SetQuitter(bool bInQuitter) { NativeCall<void, bool>(this, "AShooterPlayerState.SetQuitter", bInQuitter); }
    void CopyProperties(APlayerState * PlayerState) { NativeCall<void, APlayerState*>(this, "AShooterPlayerState.CopyProperties", 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 ServerGetPlayerWhiteListedData_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerGetPlayerWhiteListedData_Implementation"); }
    void ClientGetAlivePlayerConnectedData_Implementation(TArray<FAlivePlayerDataInfo> * list) { NativeCall<void, TArray<FAlivePlayerDataInfo>*>(this, "AShooterPlayerState.ClientGetAlivePlayerConnectedData_Implementation", list); }
    void ClientGetPlayerConnectedData_Implementation(TArray<FAdminPlayerDataInfo> * list) { NativeCall<void, TArray<FAdminPlayerDataInfo>*>(this, "AShooterPlayerState.ClientGetPlayerConnectedData_Implementation", list); }
    void ClientGetServerOptions_Implementation(FServerOptions info) { NativeCall<void, FServerOptions>(this, "AShooterPlayerState.ClientGetServerOptions_Implementation", info); }
    void ClientGetPlayerBannedData_Implementation(TArray<FAdminPlayerDataInfo> * list) { NativeCall<void, TArray<FAdminPlayerDataInfo>*>(this, "AShooterPlayerState.ClientGetPlayerBannedData_Implementation", list); }
    void ClientGetPlayerWhiteListedData_Implementation(TArray<FAdminPlayerDataInfo> * list) { NativeCall<void, TArray<FAdminPlayerDataInfo>*>(this, "AShooterPlayerState.ClientGetPlayerWhiteListedData_Implementation", list); }
    void BroadcastDeath_Implementation(AShooterPlayerState * KillerPlayerState, UDamageType * KillerDamageType, AShooterPlayerState * KilledPlayerState) { NativeCall<void, AShooterPlayerState*, UDamageType*, AShooterPlayerState*>(this, "AShooterPlayerState.BroadcastDeath_Implementation", KillerPlayerState, KillerDamageType, KilledPlayerState); }
    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty> * OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "AShooterPlayerState.GetLifetimeReplicatedProps", OutLifetimeProps); }
    void Destroyed() { NativeCall<void>(this, "AShooterPlayerState.Destroyed"); }
    void BeginPlay() { NativeCall<void>(this, "AShooterPlayerState.BeginPlay"); }
    FString * GetShortPlayerName(FString * result) { return NativeCall<FString*, FString*>(this, "AShooterPlayerState.GetShortPlayerName", result); }
    void PromoteToTribeAdmin(APlayerController * PromoterPC) { NativeCall<void, APlayerController*>(this, "AShooterPlayerState.PromoteToTribeAdmin", PromoterPC); }
    bool AddToTribe(FTribeData * MyNewTribe, bool bMergeTribe, bool bForce, bool bIsFromInvite, APlayerController * InviterPC) { return NativeCall<bool, FTribeData*, bool, bool, bool, APlayerController*>(this, "AShooterPlayerState.AddToTribe", MyNewTribe, bMergeTribe, bForce, bIsFromInvite, InviterPC); }
    void UpdateTribeData(FTribeData * TribeData) { NativeCall<void, FTribeData*>(this, "AShooterPlayerState.UpdateTribeData", TribeData); }
    void ClearTribe(bool bDontRemoveFromTribe, bool bForce, APlayerController * ForPC) { NativeCall<void, bool, bool, APlayerController*>(this, "AShooterPlayerState.ClearTribe", bDontRemoveFromTribe, bForce, ForPC); }
    bool IsInTribe() { return NativeCall<bool>(this, "AShooterPlayerState.IsInTribe"); }
    void TransferTribalObjects(FTribeData * TribeData, bool bTransferToTribe, bool bDontIncludePlayers) { NativeCall<void, FTribeData*, bool, bool>(this, "AShooterPlayerState.TransferTribalObjects", TribeData, bTransferToTribe, bDontIncludePlayers); }
    bool IsTribeOwner(unsigned int CheckPlayerDataID) { return NativeCall<bool, unsigned int>(this, "AShooterPlayerState.IsTribeOwner", CheckPlayerDataID); }
    bool IsTribeFounder() { return NativeCall<bool>(this, "AShooterPlayerState.IsTribeFounder"); }
    bool IsTribeAdmin() { return NativeCall<bool>(this, "AShooterPlayerState.IsTribeAdmin"); }
    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", groupIndex, groupData, UseCurrentlySelectedGroup); }
    bool AllowDinoOrderByGroup(APrimalDinoCharacter * orderDino) { return NativeCall<bool, APrimalDinoCharacter*>(this, "AShooterPlayerState.AllowDinoOrderByGroup", orderDino); }
    void LocalSetSelectedDinoOrderGroup(int newGroup, bool bDontToggle) { NativeCall<void, int, bool>(this, "AShooterPlayerState.LocalSetSelectedDinoOrderGroup", newGroup, bDontToggle); }
    void ServerDinoOrderGroup_AddOrRemoveDinoClass_Implementation(int groupIndex, TSubclassOf<APrimalDinoCharacter> DinoClass, bool bAdd) { NativeCall<void, int, TSubclassOf<APrimalDinoCharacter>, bool>(this, "AShooterPlayerState.ServerDinoOrderGroup_AddOrRemoveDinoClass_Implementation", groupIndex, DinoClass, bAdd); }
    void ServerSetDinoGroupName_Implementation(int groupIndex, FString * GroupName) { NativeCall<void, int, FString*>(this, "AShooterPlayerState.ServerSetDinoGroupName_Implementation", groupIndex, GroupName); }
    FString * GetDinoOrderGroupName(FString * result, int groupIndex) { return NativeCall<FString*, FString*, int>(this, "AShooterPlayerState.GetDinoOrderGroupName", result, groupIndex); }
    bool IsDinoInOrderGroup(int groupIndex, APrimalDinoCharacter * dinoChar) { return NativeCall<bool, int, APrimalDinoCharacter*>(this, "AShooterPlayerState.IsDinoInOrderGroup", groupIndex, dinoChar); }
    bool IsDinoClassInOrderGroup(int groupIndex, TSubclassOf<APrimalDinoCharacter> dinoClass) { return NativeCall<bool, int, TSubclassOf<APrimalDinoCharacter>>(this, "AShooterPlayerState.IsDinoClassInOrderGroup", groupIndex, dinoClass); }
    void ServerDinoOrderGroup_AddOrRemoveDinoCharacter_Implementation(int groupIndex, APrimalDinoCharacter * DinoCharacter, bool bAdd) { NativeCall<void, int, APrimalDinoCharacter*, bool>(this, "AShooterPlayerState.ServerDinoOrderGroup_AddOrRemoveDinoCharacter_Implementation", groupIndex, DinoCharacter, bAdd); }
    void ServerDinoOrderGroup_Clear_Implementation(int groupIndex, bool bClearClasses, bool bClearChars) { NativeCall<void, int, bool, bool>(this, "AShooterPlayerState.ServerDinoOrderGroup_Clear_Implementation", groupIndex, bClearClasses, bClearChars); }
    void ServerDinoOrderGroup_RemoveEntryByIndex_Implementation(int groupIndex, bool bIsClass, int entryIndex) { NativeCall<void, int, bool, int>(this, "AShooterPlayerState.ServerDinoOrderGroup_RemoveEntryByIndex_Implementation", groupIndex, bIsClass, entryIndex); }
    void ServerSetSelectedDinoOrderGroup_Implementation(int newGroup) { NativeCall<void, int>(this, "AShooterPlayerState.ServerSetSelectedDinoOrderGroup_Implementation", newGroup); }
    void ServerRequestRenameTribe_Implementation(FString * TribeName) { NativeCall<void, FString*>(this, "AShooterPlayerState.ServerRequestRenameTribe_Implementation", TribeName); }
    void ServerRequestSetTribeGovernment_Implementation(FTribeGovernment TribeGovernment) { NativeCall<void, FTribeGovernment>(this, "AShooterPlayerState.ServerRequestSetTribeGovernment_Implementation", TribeGovernment); }
    void ServerRequestCreateNewTribe_Implementation(FString * TribeName, FTribeGovernment TribeGovernment) { NativeCall<void, FString*, FTribeGovernment>(this, "AShooterPlayerState.ServerRequestCreateNewTribe_Implementation", TribeName, TribeGovernment); }
    void ServerRequestLeaveTribe_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerRequestLeaveTribe_Implementation"); }
    void ServerRequestRemovePlayerIndexFromMyTribe_Implementation(int PlayerIndexInTribe) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRequestRemovePlayerIndexFromMyTribe_Implementation", PlayerIndexInTribe); }
    void ServerRequestPromotePlayerInMyTribe_Implementation(int PlayerIndexInTribe) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRequestPromotePlayerInMyTribe_Implementation", PlayerIndexInTribe); }
    void ServerRequestDemotePlayerInMyTribe_Implementation(int PlayerIndexInTribe) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRequestDemotePlayerInMyTribe_Implementation", PlayerIndexInTribe); }
    void InvitedRankGroupPlayerIntoTribe(AShooterPlayerState * OtherPlayer) { NativeCall<void, AShooterPlayerState*>(this, "AShooterPlayerState.InvitedRankGroupPlayerIntoTribe", OtherPlayer); }
    void ServerRequestSetTribeMemberGroupRank_Implementation(int PlayerIndexInTribe, int RankGroupIndex) { NativeCall<void, int, int>(this, "AShooterPlayerState.ServerRequestSetTribeMemberGroupRank_Implementation", PlayerIndexInTribe, RankGroupIndex); }
    void ServerTribeRequestAddRankGroup_Implementation(FString * GroupName) { NativeCall<void, FString*>(this, "AShooterPlayerState.ServerTribeRequestAddRankGroup_Implementation", GroupName); }
    void ServerTribeRequestRemoveRankGroup_Implementation(int RankGroupIndex) { NativeCall<void, int>(this, "AShooterPlayerState.ServerTribeRequestRemoveRankGroup_Implementation", RankGroupIndex); }
    void ServerTribeRequestApplyRankGroupSettings_Implementation(int RankGroupIndex, FTribeRankGroup newGroupSettings) { NativeCall<void, int, FTribeRankGroup>(this, "AShooterPlayerState.ServerTribeRequestApplyRankGroupSettings_Implementation", RankGroupIndex, newGroupSettings); }
    void ServerRequestTransferOwnershipInMyTribe_Implementation(int PlayerIndexInTribe) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRequestTransferOwnershipInMyTribe_Implementation", 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", IgnoreBedID, FilterClass); }
    void ClientReceiveSpawnPoints_Implementation(TArray<FSpawnPointInfo> * SpawnPointsInfos) { NativeCall<void, TArray<FSpawnPointInfo>*>(this, "AShooterPlayerState.ClientReceiveSpawnPoints_Implementation", SpawnPointsInfos); }
    void ServerRequestCreateNewPlayer_Implementation(FPrimalPlayerCharacterConfigStructReplicated PlayerCharacterConfig) { NativeCall<void, FPrimalPlayerCharacterConfigStructReplicated>(this, "AShooterPlayerState.ServerRequestCreateNewPlayer_Implementation", PlayerCharacterConfig); }
    void RequestCreateNewPlayerWithArkData(UPrimalPlayerData * PlayerArkData) { NativeCall<void, UPrimalPlayerData*>(this, "AShooterPlayerState.RequestCreateNewPlayerWithArkData", PlayerArkData); }
    void ServerRequestApplyEngramPoints_Implementation(TSubclassOf<UPrimalItem> forItemEntry) { NativeCall<void, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerState.ServerRequestApplyEngramPoints_Implementation", forItemEntry); }
    void ServerUnlockEngram(TSubclassOf<UPrimalItem> forItemEntry, bool bNotifyPlayerHUD, bool bForceUnlock) { NativeCall<void, TSubclassOf<UPrimalItem>, bool, bool>(this, "AShooterPlayerState.ServerUnlockEngram", forItemEntry, bNotifyPlayerHUD, bForceUnlock); }
    bool IsAlliedWith(int OtherTeam) { return NativeCall<bool, int>(this, "AShooterPlayerState.IsAlliedWith", OtherTeam); }
    bool IsFriendly(int OtherTeam) { return NativeCall<bool, int>(this, "AShooterPlayerState.IsFriendly", OtherTeam); }
    void AddEngramBlueprintToPlayerInventory(UPrimalInventoryComponent * invComp, TSubclassOf<UPrimalItem> engramItemBlueprint) { NativeCall<void, UPrimalInventoryComponent*, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerState.AddEngramBlueprintToPlayerInventory", invComp, engramItemBlueprint); }
    AShooterPlayerController * GetShooterController() { return NativeCall<AShooterPlayerController*>(this, "AShooterPlayerState.GetShooterController"); }
    UObject * GetObjectW() { return NativeCall<UObject*>(this, "AShooterPlayerState.GetObjectW"); }
    bool HasEngram(TSubclassOf<UPrimalItem> ItemClass) { return NativeCall<bool, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerState.HasEngram", ItemClass); }
    void ReceivedPlayerCharacter(AShooterCharacter * NewPawn) { NativeCall<void, AShooterCharacter*>(this, "AShooterPlayerState.ReceivedPlayerCharacter", NewPawn); }
    void NotifyPlayerJoinedTribe_Implementation(FString * ThePlayerName, FString * TribeName) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerState.NotifyPlayerJoinedTribe_Implementation", ThePlayerName, TribeName); }
    void NotifyPlayerLeftTribe_Implementation(FString * ThePlayerName, FString * TribeName) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerState.NotifyPlayerLeftTribe_Implementation", ThePlayerName, TribeName); }
    void NotifyPlayerJoined_Implementation(FString * ThePlayerName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyPlayerJoined_Implementation", ThePlayerName); }
    void NotifyTribememberJoined_Implementation(FString * ThePlayerName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyTribememberJoined_Implementation", ThePlayerName); }
    void NotifyPlayerLeft_Implementation(FString * ThePlayerName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyPlayerLeft_Implementation", ThePlayerName); }
    void NotifyTribememberLeft_Implementation(FString * ThePlayerName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyTribememberLeft_Implementation", ThePlayerName); }
    void NotifyUniqueDinoDownloaded_Implementation(FString * TheDinoName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyUniqueDinoDownloaded_Implementation", TheDinoName); }
    void NotifyUniqueDinoDownloadAllowed_Implementation(FString * TheDinoName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyUniqueDinoDownloadAllowed_Implementation", TheDinoName); }
    AShooterHUD * GetShooterHUD() { return NativeCall<AShooterHUD*>(this, "AShooterPlayerState.GetShooterHUD"); }
    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", 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", aDinoChar); }
    void SendTribeInviteData_Implementation(FTribeData TribeInviteData) { NativeCall<void, FTribeData>(this, "AShooterPlayerState.SendTribeInviteData_Implementation", TribeInviteData); }
    void DoRespec(UPrimalPlayerData * ForPlayerData, AShooterCharacter * ForCharacter, bool bSetRespecedAtCharacterLevel) { NativeCall<void, UPrimalPlayerData*, AShooterCharacter*, bool>(this, "AShooterPlayerState.DoRespec", ForPlayerData, ForCharacter, bSetRespecedAtCharacterLevel); }
    int GetTribeId() { return NativeCall<int>(this, "AShooterPlayerState.GetTribeId"); }
    FString * GetUniqueIdString(FString * result) { return NativeCall<FString*, FString*>(this, "AShooterPlayerState.GetUniqueIdString", result); }
    bool IsAllowedToRefreshFlexPipeConnections(float Cooldown) { return NativeCall<bool, float>(this, "AShooterPlayerState.IsAllowedToRefreshFlexPipeConnections", Cooldown); }
    void ResetFlexPipeGlobalCooldown() { NativeCall<void>(this, "AShooterPlayerState.ResetFlexPipeGlobalCooldown"); }
    bool IsInTribeWar(int EnemyTeam) { return NativeCall<bool, int>(this, "AShooterPlayerState.IsInTribeWar", EnemyTeam); }
    bool HasTribeWarRequest(int EnemyTeam) { return NativeCall<bool, int>(this, "AShooterPlayerState.HasTribeWarRequest", 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", EnemyTeamID, StartDayNum, EndDayNumber, WarStartTime, WarEndTime); }
    void ServerAcceptTribeWar_Implementation(int EnemyTeamID) { NativeCall<void, int>(this, "AShooterPlayerState.ServerAcceptTribeWar_Implementation", EnemyTeamID); }
    void ServerRejectTribeWar_Implementation(int EnemyTeamID) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRejectTribeWar_Implementation", EnemyTeamID); }
    FTribeWar * GetTribeWar(FTribeWar * result, int EnemyTeam) { return NativeCall<FTribeWar*, FTribeWar*, int>(this, "AShooterPlayerState.GetTribeWar", result, EnemyTeam); }
    void ServerRequestRemoveAllianceMember_Implementation(unsigned int AllianceID, unsigned int MemberID) { NativeCall<void, unsigned int, unsigned int>(this, "AShooterPlayerState.ServerRequestRemoveAllianceMember_Implementation", AllianceID, MemberID); }
    void ServerRequestPromoteAllianceMember_Implementation(unsigned int AllianceID, unsigned int MemberID) { NativeCall<void, unsigned int, unsigned int>(this, "AShooterPlayerState.ServerRequestPromoteAllianceMember_Implementation", AllianceID, MemberID); }
    void ServerTribeRequestNewAlliance_Implementation(FString * AllianceName) { NativeCall<void, FString*>(this, "AShooterPlayerState.ServerTribeRequestNewAlliance_Implementation", AllianceName); }
    void ServerRequestLeaveAlliance_Implementation(unsigned int AllianceID) { NativeCall<void, unsigned int>(this, "AShooterPlayerState.ServerRequestLeaveAlliance_Implementation", AllianceID); }
    void AcceptJoinAlliance(unsigned int AllianceID, unsigned int NewMemberID, FString NewMemberName) { NativeCall<void, unsigned int, unsigned int, FString>(this, "AShooterPlayerState.AcceptJoinAlliance", AllianceID, NewMemberID, NewMemberName); }
    bool AllowTribeGroupPermission(ETribeGroupPermission::Type TribeGroupPermission, UObject * OnObject) { return NativeCall<bool, ETribeGroupPermission::Type, UObject*>(this, "AShooterPlayerState.AllowTribeGroupPermission", TribeGroupPermission, OnObject); }
    void ServerRequestSpawnPointsForDownloadedCharacters_Implementation(unsigned __int64 PlayerDataID, int IgnoreBedID) { NativeCall<void, unsigned __int64, int>(this, "AShooterPlayerState.ServerRequestSpawnPointsForDownloadedCharacters_Implementation", PlayerDataID, IgnoreBedID); }
    void OnRep_UpdatedEngrams() { NativeCall<void>(this, "AShooterPlayerState.OnRep_UpdatedEngrams"); }
    UObject * GetUObjectInterfaceDataListProviderInterface() { return NativeCall<UObject*>(this, "AShooterPlayerState.GetUObjectInterfaceDataListProviderInterface"); }
    static void StaticRegisterNativesAShooterPlayerState() { NativeCall<void>(nullptr, "AShooterPlayerState.StaticRegisterNativesAShooterPlayerState"); }
    static UClass * GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "AShooterPlayerState.GetPrivateStaticClass", Package); }
    void BroadcastDeath(AShooterPlayerState * KillerPlayerState, UDamageType * KillerDamageType, AShooterPlayerState * KilledPlayerState) { NativeCall<void, AShooterPlayerState*, UDamageType*, AShooterPlayerState*>(this, "AShooterPlayerState.BroadcastDeath", KillerPlayerState, KillerDamageType, KilledPlayerState); }
    void ClientGetAlivePlayerConnectedData(TArray<FAlivePlayerDataInfo> * list) { NativeCall<void, TArray<FAlivePlayerDataInfo>*>(this, "AShooterPlayerState.ClientGetAlivePlayerConnectedData", list); }
    void ClientGetPlayerBannedData(TArray<FAdminPlayerDataInfo> * list) { NativeCall<void, TArray<FAdminPlayerDataInfo>*>(this, "AShooterPlayerState.ClientGetPlayerBannedData", list); }
    void ClientGetPlayerConnectedData(TArray<FAdminPlayerDataInfo> * list) { NativeCall<void, TArray<FAdminPlayerDataInfo>*>(this, "AShooterPlayerState.ClientGetPlayerConnectedData", list); }
    void ClientGetPlayerWhiteListedData(TArray<FAdminPlayerDataInfo> * list) { NativeCall<void, TArray<FAdminPlayerDataInfo>*>(this, "AShooterPlayerState.ClientGetPlayerWhiteListedData", list); }
    void ClientGetServerOptions(FServerOptions info) { NativeCall<void, FServerOptions>(this, "AShooterPlayerState.ClientGetServerOptions", info); }
    void ClientNotifyLevelUpAvailable() { NativeCall<void>(this, "AShooterPlayerState.ClientNotifyLevelUpAvailable"); }
    void ClientReceiveSpawnPoints(TArray<FSpawnPointInfo> * SpawnPointsInfos) { NativeCall<void, TArray<FSpawnPointInfo>*>(this, "AShooterPlayerState.ClientReceiveSpawnPoints", SpawnPointsInfos); }
    void ClientRefreshDinoOrderGroup(int groupIndex, FDinoOrderGroup groupData, int UseCurrentlySelectedGroup) { NativeCall<void, int, FDinoOrderGroup, int>(this, "AShooterPlayerState.ClientRefreshDinoOrderGroup", groupIndex, groupData, UseCurrentlySelectedGroup); }
    void NotifyPlayerJoined(FString * ThePlayerName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyPlayerJoined", ThePlayerName); }
    void NotifyPlayerJoinedTribe(FString * ThePlayerName, FString * TribeName) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerState.NotifyPlayerJoinedTribe", ThePlayerName, TribeName); }
    void NotifyPlayerLeft(FString * ThePlayerName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyPlayerLeft", ThePlayerName); }
    void NotifyPlayerLeftTribe(FString * ThePlayerName, FString * TribeName) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerState.NotifyPlayerLeftTribe", ThePlayerName, TribeName); }
    void NotifyTribememberJoined(FString * ThePlayerName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyTribememberJoined", ThePlayerName); }
    void NotifyTribememberLeft(FString * ThePlayerName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyTribememberLeft", ThePlayerName); }
    void NotifyUniqueDinoDownloadAllowed(FString * TheDinoName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyUniqueDinoDownloadAllowed", TheDinoName); }
    void SendTribeInviteData(FTribeData TribeInviteData) { NativeCall<void, FTribeData>(this, "AShooterPlayerState.SendTribeInviteData", TribeInviteData); }
    void ServerAcceptTribeWar(int EnemyTeamID) { NativeCall<void, int>(this, "AShooterPlayerState.ServerAcceptTribeWar", EnemyTeamID); }
    void ServerDeclareTribeWar(int EnemyTeamID, int StartDayNum, int EndDayNumber, float WarStartTime, float WarEndTime) { NativeCall<void, int, int, int, float, float>(this, "AShooterPlayerState.ServerDeclareTribeWar", EnemyTeamID, StartDayNum, EndDayNumber, WarStartTime, WarEndTime); }
    void ServerDinoOrderGroup_AddOrRemoveDinoCharacter(int groupIndex, APrimalDinoCharacter * DinoCharacter, bool bAdd) { NativeCall<void, int, APrimalDinoCharacter*, bool>(this, "AShooterPlayerState.ServerDinoOrderGroup_AddOrRemoveDinoCharacter", groupIndex, DinoCharacter, bAdd); }
    void ServerDinoOrderGroup_AddOrRemoveDinoClass(int groupIndex, TSubclassOf<APrimalDinoCharacter> DinoClass, bool bAdd) { NativeCall<void, int, TSubclassOf<APrimalDinoCharacter>, bool>(this, "AShooterPlayerState.ServerDinoOrderGroup_AddOrRemoveDinoClass", groupIndex, DinoClass, bAdd); }
    void ServerDinoOrderGroup_Clear(int groupIndex, bool bClearClasses, bool bClearChars) { NativeCall<void, int, bool, bool>(this, "AShooterPlayerState.ServerDinoOrderGroup_Clear", groupIndex, bClearClasses, bClearChars); }
    void ServerDinoOrderGroup_RemoveEntryByIndex(int groupIndex, bool bIsClass, int entryIndex) { NativeCall<void, int, bool, int>(this, "AShooterPlayerState.ServerDinoOrderGroup_RemoveEntryByIndex", groupIndex, bIsClass, entryIndex); }
    void ServerGetAlivePlayerConnectedData() { NativeCall<void>(this, "AShooterPlayerState.ServerGetAlivePlayerConnectedData"); }
    void ServerGetAllPlayerNamesAndLocations() { NativeCall<void>(this, "AShooterPlayerState.ServerGetAllPlayerNamesAndLocations"); }
    void ServerGetPlayerBannedData() { NativeCall<void>(this, "AShooterPlayerState.ServerGetPlayerBannedData"); }
    void ServerGetPlayerConnectedData() { NativeCall<void>(this, "AShooterPlayerState.ServerGetPlayerConnectedData"); }
    void ServerGetPlayerWhiteListedData() { NativeCall<void>(this, "AShooterPlayerState.ServerGetPlayerWhiteListedData"); }
    void ServerGetServerOptions() { NativeCall<void>(this, "AShooterPlayerState.ServerGetServerOptions"); }
    void ServerRejectTribeWar(int EnemyTeamID) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRejectTribeWar", EnemyTeamID); }
    void ServerRequestApplyEngramPoints(TSubclassOf<UPrimalItem> forItemEntry) { NativeCall<void, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerState.ServerRequestApplyEngramPoints", forItemEntry); }
    void ServerRequestCreateNewPlayer(FPrimalPlayerCharacterConfigStructReplicated PlayerCharacterConfig) { NativeCall<void, FPrimalPlayerCharacterConfigStructReplicated>(this, "AShooterPlayerState.ServerRequestCreateNewPlayer", PlayerCharacterConfig); }
    void ServerRequestCreateNewTribe(FString * TribeName, FTribeGovernment TribeGovernment) { NativeCall<void, FString*, FTribeGovernment>(this, "AShooterPlayerState.ServerRequestCreateNewTribe", TribeName, TribeGovernment); }
    void ServerRequestDemotePlayerInMyTribe(int PlayerIndexInTribe) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRequestDemotePlayerInMyTribe", PlayerIndexInTribe); }
    void ServerRequestDinoOrderGroups() { NativeCall<void>(this, "AShooterPlayerState.ServerRequestDinoOrderGroups"); }
    void ServerRequestLeaveAlliance(unsigned int AllianceID) { NativeCall<void, unsigned int>(this, "AShooterPlayerState.ServerRequestLeaveAlliance", AllianceID); }
    void ServerRequestLeaveTribe() { NativeCall<void>(this, "AShooterPlayerState.ServerRequestLeaveTribe"); }
    void ServerRequestMySpawnPoints(int IgnoreBedID, TSubclassOf<APrimalStructure> FilterClass) { NativeCall<void, int, TSubclassOf<APrimalStructure>>(this, "AShooterPlayerState.ServerRequestMySpawnPoints", IgnoreBedID, FilterClass); }
    void ServerRequestPromoteAllianceMember(unsigned int AllianceID, unsigned int MemberID) { NativeCall<void, unsigned int, unsigned int>(this, "AShooterPlayerState.ServerRequestPromoteAllianceMember", AllianceID, MemberID); }
    void ServerRequestPromotePlayerInMyTribe(int PlayerIndexInTribe) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRequestPromotePlayerInMyTribe", PlayerIndexInTribe); }
    void ServerRequestRemoveAllianceMember(unsigned int AllianceID, unsigned int MemberID) { NativeCall<void, unsigned int, unsigned int>(this, "AShooterPlayerState.ServerRequestRemoveAllianceMember", AllianceID, MemberID); }
    void ServerRequestRemovePlayerIndexFromMyTribe(int PlayerIndexInTribe) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRequestRemovePlayerIndexFromMyTribe", PlayerIndexInTribe); }
    void ServerRequestRenameTribe(FString * ServerRequestRenameTribe) { NativeCall<void, FString*>(this, "AShooterPlayerState.ServerRequestRenameTribe", ServerRequestRenameTribe); }
    void ServerRequestSetTribeGovernment(FTribeGovernment TribeGovernment) { NativeCall<void, FTribeGovernment>(this, "AShooterPlayerState.ServerRequestSetTribeGovernment", TribeGovernment); }
    void ServerRequestSetTribeMemberGroupRank(int PlayerIndexInTribe, int RankGroupIndex) { NativeCall<void, int, int>(this, "AShooterPlayerState.ServerRequestSetTribeMemberGroupRank", PlayerIndexInTribe, RankGroupIndex); }
    void ServerRequestSpawnPointsForDownloadedCharacters(unsigned __int64 PlayerDataID, int IgnoreBedID) { NativeCall<void, unsigned __int64, int>(this, "AShooterPlayerState.ServerRequestSpawnPointsForDownloadedCharacters", PlayerDataID, IgnoreBedID); }
    void ServerRequestTransferOwnershipInMyTribe(int PlayerIndexInTribe) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRequestTransferOwnershipInMyTribe", PlayerIndexInTribe); }
    void ServerSetDefaultItemSlotClass(int slotNum, TSubclassOf<UPrimalItem> ItemClass, bool bIsEngram) { NativeCall<void, int, TSubclassOf<UPrimalItem>, bool>(this, "AShooterPlayerState.ServerSetDefaultItemSlotClass", slotNum, ItemClass, bIsEngram); }
    void ServerSetDinoGroupName(int groupIndex, FString * GroupName) { NativeCall<void, int, FString*>(this, "AShooterPlayerState.ServerSetDinoGroupName", groupIndex, GroupName); }
    void ServerSetSelectedDinoOrderGroup(int newGroup) { NativeCall<void, int>(this, "AShooterPlayerState.ServerSetSelectedDinoOrderGroup", newGroup); }
    void ServerTribeRequestAddRankGroup(FString * GroupName) { NativeCall<void, FString*>(this, "AShooterPlayerState.ServerTribeRequestAddRankGroup", GroupName); }
    void ServerTribeRequestApplyRankGroupSettings(int RankGroupIndex, FTribeRankGroup newGroupSettings) { NativeCall<void, int, FTribeRankGroup>(this, "AShooterPlayerState.ServerTribeRequestApplyRankGroupSettings", RankGroupIndex, newGroupSettings); }
    void ServerTribeRequestNewAlliance(FString * AllianceName) { NativeCall<void, FString*>(this, "AShooterPlayerState.ServerTribeRequestNewAlliance", AllianceName); }
    void ServerTribeRequestRemoveRankGroup(int RankGroupIndex) { NativeCall<void, int>(this, "AShooterPlayerState.ServerTribeRequestRemoveRankGroup", RankGroupIndex); }
};
 
struct AController : AActor
{
    TWeakObjectPtr<APawn> & OldPawnField() { return *GetNativePointerField<TWeakObjectPtr<APawn>*>(this, "AController.OldPawn"); }
    ACharacter * CharacterField() { return *GetNativePointerField<ACharacter**>(this, "AController.Character"); }
    APlayerState * PlayerStateField() { return *GetNativePointerField<APlayerState**>(this, "AController.PlayerState"); }
    APawn * PawnField() { return *GetNativePointerField<APawn**>(this, "AController.Pawn"); }
    FRotator & ControlRotationField() { return *GetNativePointerField<FRotator*>(this, "AController.ControlRotation"); }
    TWeakObjectPtr<AActor> & StartSpotField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "AController.StartSpot"); }
    FName & StateNameField() { return *GetNativePointerField<FName*>(this, "AController.StateName"); }
 
    // Bit fields
 
    BitFieldValue<bool, unsigned __int32> bAttachToPawn() { return { this, "AController.bAttachToPawn" }; }
 
    // Functions
 
    static UClass * GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "AController.GetPrivateStaticClass"); }
    bool IsLocalController() { return NativeCall<bool>(this, "AController.IsLocalController"); }
    void FailedToSpawnPawn() { NativeCall<void>(this, "AController.FailedToSpawnPawn"); }
    void SetInitialLocationAndRotation(FVector * NewLocation, FRotator * NewRotation) { NativeCall<void, FVector*, FRotator*>(this, "AController.SetInitialLocationAndRotation", NewLocation, NewRotation); }
    FRotator * GetControlRotation(FRotator * result) { return NativeCall<FRotator*, FRotator*>(this, "AController.GetControlRotation", result); }
    void SetControlRotation(FRotator * NewRotation) { NativeCall<void, FRotator*>(this, "AController.SetControlRotation", NewRotation); }
    void AttachToPawn(APawn * InPawn) { NativeCall<void, APawn*>(this, "AController.AttachToPawn", InPawn); }
    void DetachFromPawn() { NativeCall<void>(this, "AController.DetachFromPawn"); }
    AActor * GetViewTarget() { return NativeCall<AActor*>(this, "AController.GetViewTarget"); }
    void GetPlayerViewPoint(FVector * out_Location, FRotator * out_Rotation) { NativeCall<void, FVector*, FRotator*>(this, "AController.GetPlayerViewPoint", out_Location, out_Rotation); }
    bool LineOfSightTo(AActor * Other, FVector ViewPoint, bool bAlternateChecks) { return NativeCall<bool, AActor*, FVector, bool>(this, "AController.LineOfSightTo", Other, ViewPoint, bAlternateChecks); }
    void PostInitializeComponents() { NativeCall<void>(this, "AController.PostInitializeComponents"); }
    void Possess(APawn * InPawn) { NativeCall<void, APawn*>(this, "AController.Possess", InPawn); }
    void PawnPendingDestroy(APawn * inPawn) { NativeCall<void, APawn*>(this, "AController.PawnPendingDestroy", inPawn); }
    void Reset() { NativeCall<void>(this, "AController.Reset"); }
    void ClientSetLocation_Implementation(FVector NewLocation, FRotator NewRotation) { NativeCall<void, FVector, FRotator>(this, "AController.ClientSetLocation_Implementation", NewLocation, NewRotation); }
    void ClientSetRotation_Implementation(FRotator NewRotation, bool bResetCamera) { NativeCall<void, FRotator, bool>(this, "AController.ClientSetRotation_Implementation", NewRotation, bResetCamera); }
    void RemovePawnTickDependency(APawn * InOldPawn) { NativeCall<void, APawn*>(this, "AController.RemovePawnTickDependency", InOldPawn); }
    void AddPawnTickDependency(APawn * NewPawn) { NativeCall<void, APawn*>(this, "AController.AddPawnTickDependency", NewPawn); }
    void SetPawn(APawn * InPawn) { NativeCall<void, APawn*>(this, "AController.SetPawn", 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, UDamageType * DamageType, AActor * DamagedActor, AActor * DamageCauser) { NativeCall<void, float, UDamageType*, AActor*, AActor*>(this, "AController.InstigatedAnyDamage", Damage, DamageType, DamagedActor, DamageCauser); }
    void InitPlayerState() { NativeCall<void>(this, "AController.InitPlayerState"); }
    FRotator * GetDesiredRotation(FRotator * result) { return NativeCall<FRotator*, FRotator*>(this, "AController.GetDesiredRotation", result); }
    void GetActorEyesViewPoint(FVector * out_Location, FRotator * out_Rotation) { NativeCall<void, FVector*, FRotator*>(this, "AController.GetActorEyesViewPoint", out_Location, out_Rotation); }
    FString * GetHumanReadableName(FString * result) { return NativeCall<FString*, FString*>(this, "AController.GetHumanReadableName", result); }
    void ChangeState(FName NewState) { NativeCall<void, FName>(this, "AController.ChangeState", NewState); }
    bool IsInState(FName InStateName) { return NativeCall<bool, FName>(this, "AController.IsInState", InStateName); }
    FVector * GetNavAgentLocation(FVector * result) { return NativeCall<FVector*, FVector*>(this, "AController.GetNavAgentLocation", result); }
    void GetMoveGoalReachTest(AActor * MovingActor, FVector * MoveOffset, FVector * GoalOffset, float* GoalRadius, float* GoalHalfHeight) { NativeCall<void, AActor*, FVector*, FVector*, float*, float*>(this, "AController.GetMoveGoalReachTest", MovingActor, MoveOffset, GoalOffset, GoalRadius, GoalHalfHeight); }
    void UpdateNavigationComponents() { NativeCall<void>(this, "AController.UpdateNavigationComponents"); }
    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty> * OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "AController.GetLifetimeReplicatedProps", OutLifetimeProps); }
    static void StaticRegisterNativesAController() { NativeCall<void>(nullptr, "AController.StaticRegisterNativesAController"); }
    void ClientSetRotation(FRotator NewRotation, bool bResetCamera) { NativeCall<void, FRotator, bool>(this, "AController.ClientSetRotation", NewRotation, bResetCamera); }
    void ReceiveInstigatedAnyDamage(float Damage, UDamageType * DamageType, AActor * DamagedActor, AActor * DamageCauser) { NativeCall<void, float, UDamageType*, AActor*, AActor*>(this, "AController.ReceiveInstigatedAnyDamage", Damage, DamageType, DamagedActor, DamageCauser); }
};
 
struct APlayerController : AController
{
    UPlayer* PlayerField() { return *GetNativePointerField<UPlayer**>(this, "APlayerController.Player"); }
    APawn* AcknowledgedPawnField() { return *GetNativePointerField<APawn**>(this, "APlayerController.AcknowledgedPawn"); }
    float& LocalPlayerCachedLODDistanceFactorField() { return *GetNativePointerField<float*>(this, "APlayerController.LocalPlayerCachedLODDistanceFactor"); }
    AHUD* MyHUDField() { return *GetNativePointerField<AHUD**>(this, "APlayerController.MyHUD"); }
    APlayerCameraManager* PlayerCameraManagerField() { return *GetNativePointerField<APlayerCameraManager**>(this, "APlayerController.PlayerCameraManager"); }
    TSubclassOf<APlayerCameraManager>& PlayerCameraManagerClassField() { return *GetNativePointerField<TSubclassOf<APlayerCameraManager>*>(this, "APlayerController.PlayerCameraManagerClass"); }
    bool& bAutoManageActiveCameraTargetField() { return *GetNativePointerField<bool*>(this, "APlayerController.bAutoManageActiveCameraTarget"); }
    FRotator& TargetViewRotationField() { return *GetNativePointerField<FRotator*>(this, "APlayerController.TargetViewRotation"); }
    FRotator& BlendedTargetViewRotationField() { return *GetNativePointerField<FRotator*>(this, "APlayerController.BlendedTargetViewRotation"); }
    TArray<AActor*> HiddenActorsField() { return *GetNativePointerField<TArray<AActor*>*>(this, "APlayerController.HiddenActors"); }
    float& LastSpectatorStateSynchTimeField() { return *GetNativePointerField<float*>(this, "APlayerController.LastSpectatorStateSynchTime"); }
    int& ClientCapField() { return *GetNativePointerField<int*>(this, "APlayerController.ClientCap"); }
    long double& ServerLastReceivedSpectatorLocTimeField() { return *GetNativePointerField<long double*>(this, "APlayerController.ServerLastReceivedSpectatorLocTime"); }
    UCheatManager* CheatManagerField() { return *GetNativePointerField<UCheatManager**>(this, "APlayerController.CheatManager"); }
    TSubclassOf<UCheatManager>& CheatClassField() { return *GetNativePointerField<TSubclassOf<UCheatManager>*>(this, "APlayerController.CheatClass"); }
    UPlayerInput* PlayerInputField() { return *GetNativePointerField<UPlayerInput**>(this, "APlayerController.PlayerInput"); }
    TArray<FName>& PendingMapChangeLevelNamesField() { return *GetNativePointerField<TArray<FName>*>(this, "APlayerController.PendingMapChangeLevelNames"); }
    char& NetPlayerIndexField() { return *GetNativePointerField<char*>(this, "APlayerController.NetPlayerIndex"); }
    FPlayerMuteList& MuteListField() { return *GetNativePointerField<FPlayerMuteList*>(this, "APlayerController.MuteList"); }
    UNetConnection* PendingSwapConnectionField() { return *GetNativePointerField<UNetConnection**>(this, "APlayerController.PendingSwapConnection"); }
    UNetConnection* NetConnectionField() { return *GetNativePointerField<UNetConnection**>(this, "APlayerController.NetConnection"); }
    FRotator& RotationInputField() { return *GetNativePointerField<FRotator*>(this, "APlayerController.RotationInput"); }
    FRotator& PreviousRotationInputField() { return *GetNativePointerField<FRotator*>(this, "APlayerController.PreviousRotationInput"); }
    float& InputYawScaleField() { return *GetNativePointerField<float*>(this, "APlayerController.InputYawScale"); }
    float& InputPitchScaleField() { return *GetNativePointerField<float*>(this, "APlayerController.InputPitchScale"); }
    float& InputRollScaleField() { return *GetNativePointerField<float*>(this, "APlayerController.InputRollScale"); }
    TEnumAsByte<enum EMouseCursor::Type>& DefaultMouseCursorField() { return *GetNativePointerField<TEnumAsByte<enum EMouseCursor::Type>*>(this, "APlayerController.DefaultMouseCursor"); }
    TEnumAsByte<enum EMouseCursor::Type>& CurrentMouseCursorField() { return *GetNativePointerField<TEnumAsByte<enum EMouseCursor::Type>*>(this, "APlayerController.CurrentMouseCursor"); }
    TEnumAsByte<enum ECollisionChannel>& DefaultClickTraceChannelField() { return *GetNativePointerField<TEnumAsByte<enum ECollisionChannel>*>(this, "APlayerController.DefaultClickTraceChannel"); }
    TEnumAsByte<enum ECollisionChannel>& CurrentClickTraceChannelField() { return *GetNativePointerField<TEnumAsByte<enum ECollisionChannel>*>(this, "APlayerController.CurrentClickTraceChannel"); }
    bool& bLockedInputUIField() { return *GetNativePointerField<bool*>(this, "APlayerController.bLockedInputUI"); }
    TSubobjectPtr<USceneComponent>& TransformComponentField() { return *GetNativePointerField<TSubobjectPtr<USceneComponent>*>(this, "APlayerController.TransformComponent"); }
    TWeakObjectPtr<UPrimitiveComponent>& CurrentClickablePrimitiveField() { return *GetNativePointerField<TWeakObjectPtr<UPrimitiveComponent>*>(this, "APlayerController.CurrentClickablePrimitive"); }
    FieldArray<TWeakObjectPtr<UPrimitiveComponent>, 11> CurrentTouchablePrimitivesField() { return { this, "APlayerController.CurrentTouchablePrimitives" }; }
    char& IgnoreMoveInputField() { return *GetNativePointerField<char*>(this, "APlayerController.IgnoreMoveInput"); }
    char& IgnoreLookInputField() { return *GetNativePointerField<char*>(this, "APlayerController.IgnoreLookInput"); }
    TWeakObjectPtr<USceneComponent>& AudioListenerComponentField() { return *GetNativePointerField<TWeakObjectPtr<USceneComponent>*>(this, "APlayerController.AudioListenerComponent"); }
    FVector& AudioListenerLocationOverrideField() { return *GetNativePointerField<FVector*>(this, "APlayerController.AudioListenerLocationOverride"); }
    FRotator& AudioListenerRotationOverrideField() { return *GetNativePointerField<FRotator*>(this, "APlayerController.AudioListenerRotationOverride"); }
    ASpectatorPawn* SpectatorPawnField() { return *GetNativePointerField<ASpectatorPawn**>(this, "APlayerController.SpectatorPawn"); }
    FVector& SpawnLocationField() { return *GetNativePointerField<FVector*>(this, "APlayerController.SpawnLocation"); }
    float& LastRetryPlayerTimeField() { return *GetNativePointerField<float*>(this, "APlayerController.LastRetryPlayerTime"); }
    unsigned __int16& SeamlessTravelCountField() { return *GetNativePointerField<unsigned __int16*>(this, "APlayerController.SeamlessTravelCount"); }
    unsigned __int16& LastCompletedSeamlessTravelCountField() { return *GetNativePointerField<unsigned __int16*>(this, "APlayerController.LastCompletedSeamlessTravelCount"); }
    TArray<AActor*> AlwaysReleventNetworkActorsField() { return *GetNativePointerField<TArray<AActor*>*>(this, "APlayerController.AlwaysReleventNetworkActors"); }
    FVector& LastReplicatedFocalLocField() { return *GetNativePointerField<FVector*>(this, "APlayerController.LastReplicatedFocalLoc"); }
    bool& bIsDelayedNetCleanupField() { return *GetNativePointerField<bool*>(this, "APlayerController.bIsDelayedNetCleanup"); }
    float& LastTeleportDistanceField() { return *GetNativePointerField<float*>(this, "APlayerController.LastTeleportDistance"); }
 
    // Bit fields
 
    BitFieldValue<bool, unsigned __int32> bShortConnectTimeOut() { return { this, "APlayerController.bShortConnectTimeOut" }; }
    BitFieldValue<bool, unsigned __int32> bShowExtendedInfoKey() { return { this, "APlayerController.bShowExtendedInfoKey" }; }
    BitFieldValue<bool, unsigned __int32> bIsAnselActive() { return { this, "APlayerController.bIsAnselActive" }; }
    BitFieldValue<bool, unsigned __int32> bForceSpawnedNotification() { return { this, "APlayerController.bForceSpawnedNotification" }; }
    BitFieldValue<bool, unsigned __int32> bCinematicMode() { return { this, "APlayerController.bCinematicMode" }; }
    BitFieldValue<bool, unsigned __int32> bIsUsingStreamingVolumes() { return { this, "APlayerController.bIsUsingStreamingVolumes" }; }
    BitFieldValue<bool, unsigned __int32> bPlayerIsWaiting() { return { this, "APlayerController.bPlayerIsWaiting" }; }
    BitFieldValue<bool, unsigned __int32> bCheatPlayer() { return { this, "APlayerController.bCheatPlayer" }; }
    BitFieldValue<bool, unsigned __int32> bIsAdmin() { return { this, "APlayerController.bIsAdmin" }; }
    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> bCinemaDisableInputMove() { return { this, "APlayerController.bCinemaDisableInputMove" }; }
    BitFieldValue<bool, unsigned __int32> bCinemaDisableInputLook() { return { this, "APlayerController.bCinemaDisableInputLook" }; }
    BitFieldValue<bool, unsigned __int32> bAcknowledgedClientReceivedActor() { return { this, "APlayerController.bAcknowledgedClientReceivedActor" }; }
    BitFieldValue<bool, unsigned __int32> bInputEnabled() { return { this, "APlayerController.bInputEnabled" }; }
    BitFieldValue<bool, unsigned __int32> bShouldPerformFullTickWhenPaused() { return { this, "APlayerController.bShouldPerformFullTickWhenPaused" }; }
    BitFieldValue<bool, unsigned __int32> bOverrideAudioListener() { return { this, "APlayerController.bOverrideAudioListener" }; }
 
    // Functions
 
    TArray<AActor*>* GetAlwaysReleventNetworkActors() { return NativeCall<TArray<AActor*>*>(this, "APlayerController.GetAlwaysReleventNetworkActors"); }
    void SetKickedNotification(FString APIKey) { NativeCall<void, FString>(this, "APlayerController.SetKickedNotification", APIKey); }
    AActor* GetAimedUseActor(UActorComponent** UseComponent, int* hitBodyIndex, bool bForceUseActorLocation) { return NativeCall<AActor*, UActorComponent**, int*, bool>(this, "APlayerController.GetAimedUseActor", UseComponent, hitBodyIndex, bForceUseActorLocation); }
    AActor* BaseGetPlayerCharacter() { return NativeCall<AActor*>(this, "APlayerController.BaseGetPlayerCharacter"); }
    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "APlayerController.StaticClass"); }
    AHUD* GetHUD() { return NativeCall<AHUD*>(this, "APlayerController.GetHUD"); }
    FVector* GetSpawnLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APlayerController.GetSpawnLocation", result); }
    void ClientPlaySoundAtLocation_Implementation(USoundBase* Sound, FVector Location, float VolumeMultiplier, float PitchMultiplier) { NativeCall<void, USoundBase*, FVector, float, float>(this, "APlayerController.ClientPlaySoundAtLocation_Implementation", Sound, Location, VolumeMultiplier, PitchMultiplier); }
    UPlayer* GetNetOwningPlayer() { return NativeCall<UPlayer*>(this, "APlayerController.GetNetOwningPlayer"); }
    UNetConnection* GetNetConnection() { return NativeCall<UNetConnection*>(this, "APlayerController.GetNetConnection"); }
    bool IsLocalController() { return NativeCall<bool>(this, "APlayerController.IsLocalController"); }
    bool ServerPause_Validate() { return NativeCall<bool>(this, "APlayerController.ServerPause_Validate"); }
    void FailedToSpawnPawn() { NativeCall<void>(this, "APlayerController.FailedToSpawnPawn"); }
    void ClientFlushLevelStreaming_Implementation() { NativeCall<void>(this, "APlayerController.ClientFlushLevelStreaming_Implementation"); }
    void ServerUpdateLevelVisibility_Implementation(FName PackageName, bool bIsVisible) { NativeCall<void, FName, bool>(this, "APlayerController.ServerUpdateLevelVisibility_Implementation", PackageName, bIsVisible); }
    bool ServerUpdateLevelVisibility_Validate(FName PackageName, bool bIsVisible) { return NativeCall<bool, FName, bool>(this, "APlayerController.ServerUpdateLevelVisibility_Validate", PackageName, bIsVisible); }
    FString* ConsoleCommand(FString* result, FString* Cmd, bool bWriteToLog) { return NativeCall<FString*, FString*, FString*, bool>(this, "APlayerController.ConsoleCommand", result, Cmd, bWriteToLog); }
    void CleanUpAudioComponents() { NativeCall<void>(this, "APlayerController.CleanUpAudioComponents"); }
    AActor* GetViewTarget() { return NativeCall<AActor*>(this, "APlayerController.GetViewTarget"); }
    void AutoManageActiveCameraTarget(AActor* SuggestedTarget) { NativeCall<void, AActor*>(this, "APlayerController.AutoManageActiveCameraTarget", SuggestedTarget); }
    bool ServerNotifyLoadedWorld_Validate(FName WorldPackageName) { return NativeCall<bool, FName>(this, "APlayerController.ServerNotifyLoadedWorld_Validate", WorldPackageName); }
    void ServerNotifyLoadedWorld_Implementation(FName WorldPackageName) { NativeCall<void, FName>(this, "APlayerController.ServerNotifyLoadedWorld_Implementation", WorldPackageName); }
    bool HasClientLoadedCurrentWorld() { return NativeCall<bool>(this, "APlayerController.HasClientLoadedCurrentWorld"); }
    void ForceSingleNetUpdateFor(AActor* Target) { NativeCall<void, AActor*>(this, "APlayerController.ForceSingleNetUpdateFor", Target); }
    void SmoothTargetViewRotation(APawn* TargetPawn, float DeltaSeconds) { NativeCall<void, APawn*, float>(this, "APlayerController.SmoothTargetViewRotation", 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", NewPawn); }
    void ClientRestart_Implementation(APawn* NewPawn) { NativeCall<void, APawn*>(this, "APlayerController.ClientRestart_Implementation", NewPawn); }
    void Possess(APawn* PawnToPossess) { NativeCall<void, APawn*>(this, "APlayerController.Possess", PawnToPossess); }
    void AcknowledgePossession(APawn* P) { NativeCall<void, APawn*>(this, "APlayerController.AcknowledgePossession", P); }
    void ReceivedPlayer() { NativeCall<void>(this, "APlayerController.ReceivedPlayer"); }
    FVector* GetFocalLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APlayerController.GetFocalLocation", result); }
    void PostLoad() { NativeCall<void>(this, "APlayerController.PostLoad"); }
    void GetActorEyesViewPoint(FVector* out_Location, FRotator* out_Rotation) { NativeCall<void, FVector*, FRotator*>(this, "APlayerController.GetActorEyesViewPoint", out_Location, out_Rotation); }
    void CalcCamera(float DeltaTime, FMinimalViewInfo* OutResult) { NativeCall<void, float, FMinimalViewInfo*>(this, "APlayerController.CalcCamera", DeltaTime, OutResult); }
    void GetPlayerViewPoint(FVector* out_Location, FRotator* out_Rotation) { NativeCall<void, FVector*, FRotator*>(this, "APlayerController.GetPlayerViewPoint", out_Location, out_Rotation); }
    void UpdateRotation(float DeltaTime) { NativeCall<void, float>(this, "APlayerController.UpdateRotation", DeltaTime); }
    void PostInitializeComponents() { NativeCall<void>(this, "APlayerController.PostInitializeComponents"); }
    void AddCheats(bool bForce) { NativeCall<void, bool>(this, "APlayerController.AddCheats", bForce); }
    void EnableCheats(FString pass) { NativeCall<void, FString>(this, "APlayerController.EnableCheats", pass); }
    void SpawnDefaultHUD() { NativeCall<void>(this, "APlayerController.SpawnDefaultHUD"); }
    void CreateTouchInterface() { NativeCall<void>(this, "APlayerController.CreateTouchInterface"); }
    void CleanupGameViewport() { NativeCall<void>(this, "APlayerController.CleanupGameViewport"); }
    void GetViewportSize(int* SizeX, int* SizeY) { NativeCall<void, int*, int*>(this, "APlayerController.GetViewportSize", SizeX, SizeY); }
    void Reset() { NativeCall<void>(this, "APlayerController.Reset"); }
    void ClientReset_Implementation() { NativeCall<void>(this, "APlayerController.ClientReset_Implementation"); }
    void ClientGotoState_Implementation(FName NewState) { NativeCall<void, FName>(this, "APlayerController.ClientGotoState_Implementation", NewState); }
    bool IsFrozen() { return NativeCall<bool>(this, "APlayerController.IsFrozen"); }
    void ServerAcknowledgePossession_Implementation(APawn* P) { NativeCall<void, APawn*>(this, "APlayerController.ServerAcknowledgePossession_Implementation", P); }
    bool ServerAcknowledgePossession_Validate(APawn* P) { return NativeCall<bool, APawn*>(this, "APlayerController.ServerAcknowledgePossession_Validate", P); }
    void UnPossess() { NativeCall<void>(this, "APlayerController.UnPossess"); }
    void ClientSetHUD_Implementation(TSubclassOf<AHUD> NewHUDClass) { NativeCall<void, TSubclassOf<AHUD>>(this, "APlayerController.ClientSetHUD_Implementation", NewHUDClass); }
    void CleanupPlayerState() { NativeCall<void>(this, "APlayerController.CleanupPlayerState"); }
    void OnNetCleanup(UNetConnection* Connection) { NativeCall<void, UNetConnection*>(this, "APlayerController.OnNetCleanup", Connection); }
    void DelayedNetCleanup() { NativeCall<void>(this, "APlayerController.DelayedNetCleanup"); }
    void ClientPlaySound_Implementation(USoundBase* Sound, float VolumeMultiplier, float PitchMultiplier) { NativeCall<void, USoundBase*, float, float>(this, "APlayerController.ClientPlaySound_Implementation", Sound, VolumeMultiplier, PitchMultiplier); }
    void ClientTeamMessage_Implementation(APlayerState* SenderPlayerState, FString* S, FName Type, float MsgLifeTime) { NativeCall<void, APlayerState*, FString*, FName, float>(this, "APlayerController.ClientTeamMessage_Implementation", SenderPlayerState, S, Type, MsgLifeTime); }
    void ServerToggleAILogging_Implementation() { NativeCall<void>(this, "APlayerController.ServerToggleAILogging_Implementation"); }
    void PawnLeavingGame() { NativeCall<void>(this, "APlayerController.PawnLeavingGame"); }
    void EndPlay(EEndPlayReason::Type EndPlayReason) { NativeCall<void, EEndPlayReason::Type>(this, "APlayerController.EndPlay", EndPlayReason); }
    void Destroyed() { NativeCall<void>(this, "APlayerController.Destroyed"); }
    void FOV(float F) { NativeCall<void, float>(this, "APlayerController.FOV", F); }
    void Camera(FName NewMode) { NativeCall<void, FName>(this, "APlayerController.Camera", NewMode); }
    void ServerCamera_Implementation(FName NewMode) { NativeCall<void, FName>(this, "APlayerController.ServerCamera_Implementation", NewMode); }
    void SetCameraMode(FName NewCamMode) { NativeCall<void, FName>(this, "APlayerController.SetCameraMode", NewCamMode); }
    void ResetCameraMode() { NativeCall<void>(this, "APlayerController.ResetCameraMode"); }
    void ClientSetCameraFade_Implementation(bool bEnableFading, FColor FadeColor, FVector2D FadeAlpha, float FadeTime, bool bFadeAudio) { NativeCall<void, bool, FColor, FVector2D, float, bool>(this, "APlayerController.ClientSetCameraFade_Implementation", bEnableFading, FadeColor, FadeAlpha, FadeTime, bFadeAudio); }
    void SendClientAdjustment() { NativeCall<void>(this, "APlayerController.SendClientAdjustment"); }
    void ClientCapBandwidth_Implementation(int Cap) { NativeCall<void, int>(this, "APlayerController.ClientCapBandwidth_Implementation", Cap); }
    void SetSpawnLocation(FVector* NewLocation) { NativeCall<void, FVector*>(this, "APlayerController.SetSpawnLocation", NewLocation); }
    void SetInitialLocationAndRotation(FVector* NewLocation, FRotator* NewRotation) { NativeCall<void, FVector*, FRotator*>(this, "APlayerController.SetInitialLocationAndRotation", NewLocation, NewRotation); }
    void ServerUpdateCamera_Implementation(FVector_NetQuantize CamLoc, int CamPitchAndYaw) { NativeCall<void, FVector_NetQuantize, int>(this, "APlayerController.ServerUpdateCamera_Implementation", CamLoc, CamPitchAndYaw); }
    void ClientReturnToMainMenu_Implementation(FString* ReturnReason) { NativeCall<void, FString*>(this, "APlayerController.ClientReturnToMainMenu_Implementation", ReturnReason); }
    bool IsPaused() { return NativeCall<bool>(this, "APlayerController.IsPaused"); }
    void Pause() { NativeCall<void>(this, "APlayerController.Pause"); }
    void ServerPause_Implementation() { NativeCall<void>(this, "APlayerController.ServerPause_Implementation"); }
    void SetName(FString* S) { NativeCall<void, FString*>(this, "APlayerController.SetName", S); }
    void ServerChangeName_Implementation(FString* S) { NativeCall<void, FString*>(this, "APlayerController.ServerChangeName_Implementation", S); }
    bool ServerChangeName_Validate(FString* S) { return NativeCall<bool, FString*>(this, "APlayerController.ServerChangeName_Validate", S); }
    void NotifyLoadedWorld(FName WorldPackageName, bool bFinalDest) { NativeCall<void, FName, bool>(this, "APlayerController.NotifyLoadedWorld", WorldPackageName, bFinalDest); }
    void GameHasEnded(AActor* EndGameFocus, bool bIsWinner) { NativeCall<void, AActor*, bool>(this, "APlayerController.GameHasEnded", EndGameFocus, bIsWinner); }
    void ClientGameEnded_Implementation(AActor* EndGameFocus, bool bIsWinner) { NativeCall<void, AActor*, bool>(this, "APlayerController.ClientGameEnded_Implementation", EndGameFocus, bIsWinner); }
    bool GetHitResultUnderCursor(ECollisionChannel TraceChannel, bool bTraceComplex, FHitResult* HitResult) { return NativeCall<bool, ECollisionChannel, bool, FHitResult*>(this, "APlayerController.GetHitResultUnderCursor", TraceChannel, bTraceComplex, HitResult); }
    bool GetHitResultUnderCursorByChannel(ETraceTypeQuery TraceChannel, bool bTraceComplex, FHitResult* HitResult) { return NativeCall<bool, ETraceTypeQuery, bool, FHitResult*>(this, "APlayerController.GetHitResultUnderCursorByChannel", TraceChannel, bTraceComplex, HitResult); }
    bool GetHitResultUnderCursorForObjects(TArray<TEnumAsByte<enum EObjectTypeQuery>>* ObjectTypes, bool bTraceComplex, FHitResult* HitResult) { return NativeCall<bool, TArray<TEnumAsByte<enum EObjectTypeQuery>>*, bool, FHitResult*>(this, "APlayerController.GetHitResultUnderCursorForObjects", ObjectTypes, bTraceComplex, HitResult); }
    bool GetHitResultUnderFinger(ETouchIndex::Type FingerIndex, ECollisionChannel TraceChannel, bool bTraceComplex, FHitResult* HitResult) { return NativeCall<bool, ETouchIndex::Type, ECollisionChannel, bool, FHitResult*>(this, "APlayerController.GetHitResultUnderFinger", FingerIndex, TraceChannel, bTraceComplex, HitResult); }
    bool GetHitResultUnderFingerByChannel(ETouchIndex::Type FingerIndex, ETraceTypeQuery TraceChannel, bool bTraceComplex, FHitResult* HitResult) { return NativeCall<bool, ETouchIndex::Type, ETraceTypeQuery, bool, FHitResult*>(this, "APlayerController.GetHitResultUnderFingerByChannel", FingerIndex, TraceChannel, bTraceComplex, HitResult); }
    bool GetHitResultUnderFingerForObjects(ETouchIndex::Type FingerIndex, TArray<TEnumAsByte<enum EObjectTypeQuery>>* ObjectTypes, bool bTraceComplex, FHitResult* HitResult) { return NativeCall<bool, ETouchIndex::Type, TArray<TEnumAsByte<enum EObjectTypeQuery>>*, bool, FHitResult*>(this, "APlayerController.GetHitResultUnderFingerForObjects", FingerIndex, ObjectTypes, bTraceComplex, HitResult); }
    bool DeprojectMousePositionToWorld(FVector* WorldLocation, FVector* WorldDirection) { return NativeCall<bool, FVector*, FVector*>(this, "APlayerController.DeprojectMousePositionToWorld", WorldLocation, WorldDirection); }
    bool DeprojectScreenPositionToWorld(float ScreenX, float ScreenY, FVector* WorldLocation, FVector* WorldDirection) { return NativeCall<bool, float, float, FVector*, FVector*>(this, "APlayerController.DeprojectScreenPositionToWorld", ScreenX, ScreenY, WorldLocation, WorldDirection); }
    bool ProjectWorldLocationToScreen(FVector WorldLocation, FVector2D* ScreenLocation, FVector* Out_ViewLocation, FBox2D* Out_ViewRect, bool* Out_bIsScreenLocationInsideViewRect) { return NativeCall<bool, FVector, FVector2D*, FVector*, FBox2D*, bool*>(this, "APlayerController.ProjectWorldLocationToScreen", WorldLocation, ScreenLocation, Out_ViewLocation, Out_ViewRect, Out_bIsScreenLocationInsideViewRect); }
    bool GetHitResultAtScreenPosition(FVector2D ScreenPosition, ECollisionChannel TraceChannel, bool bTraceComplex, FHitResult* HitResult) { return NativeCall<bool, FVector2D, ECollisionChannel, bool, FHitResult*>(this, "APlayerController.GetHitResultAtScreenPosition", ScreenPosition, TraceChannel, bTraceComplex, HitResult); }
    bool GetHitResultAtScreenPosition(FVector2D ScreenPosition, ETraceTypeQuery TraceChannel, bool bTraceComplex, FHitResult* HitResult) { return NativeCall<bool, FVector2D, ETraceTypeQuery, bool, FHitResult*>(this, "APlayerController.GetHitResultAtScreenPosition", ScreenPosition, TraceChannel, bTraceComplex, HitResult); }
    bool GetHitResultAtScreenPosition(FVector2D ScreenPosition, TArray<TEnumAsByte<enum EObjectTypeQuery>>* ObjectTypes, bool bTraceComplex, FHitResult* HitResult) { return NativeCall<bool, FVector2D, TArray<TEnumAsByte<enum EObjectTypeQuery>>*, bool, FHitResult*>(this, "APlayerController.GetHitResultAtScreenPosition", ScreenPosition, ObjectTypes, bTraceComplex, HitResult); }
    void PlayerTick(float DeltaTime) { NativeCall<void, float>(this, "APlayerController.PlayerTick", DeltaTime); }
    void FlushPressedKeys() { NativeCall<void>(this, "APlayerController.FlushPressedKeys"); }
    bool InputKey(FKey Key, EInputEvent EventType, float AmountDepressed, bool bGamepad) { return NativeCall<bool, FKey, EInputEvent, float, bool>(this, "APlayerController.InputKey", Key, EventType, AmountDepressed, bGamepad); }
    bool InputAxis(FKey Key, float Delta, float DeltaTime, int NumSamples, bool bGamepad) { return NativeCall<bool, FKey, float, float, int, bool>(this, "APlayerController.InputAxis", Key, Delta, DeltaTime, NumSamples, bGamepad); }
    bool InputTouch(unsigned int Handle, ETouchType::Type Type, FVector2D* TouchLocation, FDateTime DeviceTimestamp, unsigned int TouchpadIndex) { return NativeCall<bool, unsigned int, ETouchType::Type, FVector2D*, FDateTime, unsigned int>(this, "APlayerController.InputTouch", Handle, Type, TouchLocation, DeviceTimestamp, TouchpadIndex); }
    bool InputMotion(FVector* Tilt, FVector* RotationRate, FVector* Gravity, FVector* Acceleration) { return NativeCall<bool, FVector*, FVector*, FVector*, FVector*>(this, "APlayerController.InputMotion", Tilt, RotationRate, Gravity, Acceleration); }
    bool ShouldShowMouseCursor() { return NativeCall<bool>(this, "APlayerController.ShouldShowMouseCursor"); }
    EMouseCursor::Type GetMouseCursor() { return NativeCall<EMouseCursor::Type>(this, "APlayerController.GetMouseCursor"); }
    void SetupInputComponent() { NativeCall<void>(this, "APlayerController.SetupInputComponent"); }
    void ProcessPlayerInput(const float DeltaTime, const bool bGamePaused) { NativeCall<void, const float, const bool>(this, "APlayerController.ProcessPlayerInput", DeltaTime, bGamePaused); }
    void PostProcessInput(const float DeltaTime, const bool bGamePaused) { NativeCall<void, const float, const bool>(this, "APlayerController.PostProcessInput", 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", bInCinematicMode, bAffectsMovement, bAffectsTurning); }
    void SetIgnoreMoveInput(bool bNewMoveInput) { NativeCall<void, bool>(this, "APlayerController.SetIgnoreMoveInput", bNewMoveInput); }
    bool IsMoveInputIgnored() { return NativeCall<bool>(this, "APlayerController.IsMoveInputIgnored"); }
    void SetIgnoreLookInput(bool bNewLookInput) { NativeCall<void, bool>(this, "APlayerController.SetIgnoreLookInput", bNewLookInput); }
    bool IsLookInputIgnored() { return NativeCall<bool>(this, "APlayerController.IsLookInputIgnored"); }
    void ServerVerifyViewTarget_Implementation() { NativeCall<void>(this, "APlayerController.ServerVerifyViewTarget_Implementation"); }
    void SpawnPlayerCameraManager() { NativeCall<void>(this, "APlayerController.SpawnPlayerCameraManager"); }
    void GetAudioListenerPosition(FVector* OutLocation, FVector* OutFrontDir, FVector* OutRightDir) { NativeCall<void, FVector*, FVector*, FVector*>(this, "APlayerController.GetAudioListenerPosition", OutLocation, OutFrontDir, OutRightDir); }
    void SetAudioListenerOverride(USceneComponent* AttachedComponent, FVector Location, FRotator Rotation) { NativeCall<void, USceneComponent*, FVector, FRotator>(this, "APlayerController.SetAudioListenerOverride", AttachedComponent, Location, Rotation); }
    void ClearAudioListenerOverride() { NativeCall<void>(this, "APlayerController.ClearAudioListenerOverride"); }
    void ServerCheckClientPossession_Implementation() { NativeCall<void>(this, "APlayerController.ServerCheckClientPossession_Implementation"); }
    void SafeServerCheckClientPossession() { NativeCall<void>(this, "APlayerController.SafeServerCheckClientPossession"); }
    void SafeServerUpdateSpectatorState() { NativeCall<void>(this, "APlayerController.SafeServerUpdateSpectatorState"); }
    void ServerSetSpectatorLocation_Implementation(FVector NewLoc) { NativeCall<void, FVector>(this, "APlayerController.ServerSetSpectatorLocation_Implementation", NewLoc); }
    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", dir); }
    void ViewAPlayer(int dir) { NativeCall<void, int>(this, "APlayerController.ViewAPlayer", dir); }
    void StartFire(char FireModeNum) { NativeCall<void, char>(this, "APlayerController.StartFire", FireModeNum); }
    bool NotifyServerReceivedClientData(APawn* InPawn, float TimeStamp) { return NativeCall<bool, APawn*, float>(this, "APlayerController.NotifyServerReceivedClientData", 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", bIgnore); }
    void ClientIgnoreLookInput_Implementation(bool bIgnore) { NativeCall<void, bool>(this, "APlayerController.ClientIgnoreLookInput_Implementation", bIgnore); }
    void SetCinematicMode(bool bInCinematicMode, bool bHidePlayer, bool bAffectsHUD, bool bAffectsMovement, bool bAffectsTurning) { NativeCall<void, bool, bool, bool, bool, bool>(this, "APlayerController.SetCinematicMode", 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", bInCinematicMode, bAffectsMovement, bAffectsTurning, bAffectsHUD); }
    void ClientForceGarbageCollection_Implementation() { NativeCall<void>(this, "APlayerController.ClientForceGarbageCollection_Implementation"); }
    void ClientPrepareMapChange_Implementation(FName LevelName, bool bFirst, bool bLast) { NativeCall<void, FName, bool, bool>(this, "APlayerController.ClientPrepareMapChange_Implementation", 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*>* ActorList) { NativeCall<void, bool, TArray<AActor*>*>(this, "APlayerController.GetSeamlessTravelActorList", bToEntry, ActorList); }
    void SeamlessTravelFrom(APlayerController* OldPC) { NativeCall<void, APlayerController*>(this, "APlayerController.SeamlessTravelFrom", OldPC); }
    void ClientEnableNetworkVoice_Implementation(bool bEnable) { NativeCall<void, bool>(this, "APlayerController.ClientEnableNetworkVoice_Implementation", bEnable); }
    void StartTalking() { NativeCall<void>(this, "APlayerController.StartTalking"); }
    void StopTalking() { NativeCall<void>(this, "APlayerController.StopTalking"); }
    void ToggleSpeaking(bool bSpeaking, bool bUseSuperRange) { NativeCall<void, bool, bool>(this, "APlayerController.ToggleSpeaking", bSpeaking, bUseSuperRange); }
    void ClientVoiceHandshakeComplete_Implementation() { NativeCall<void>(this, "APlayerController.ClientVoiceHandshakeComplete_Implementation"); }
    void ServerMutePlayer_Implementation(FUniqueNetIdRepl PlayerId) { NativeCall<void, FUniqueNetIdRepl>(this, "APlayerController.ServerMutePlayer_Implementation", PlayerId); }
    bool ServerUnmutePlayer_Validate(FUniqueNetIdRepl PlayerId) { return NativeCall<bool, FUniqueNetIdRepl>(this, "APlayerController.ServerUnmutePlayer_Validate", PlayerId); }
    void ServerUnmutePlayer_Implementation(FUniqueNetIdRepl PlayerId) { NativeCall<void, FUniqueNetIdRepl>(this, "APlayerController.ServerUnmutePlayer_Implementation", PlayerId); }
    void ClientMutePlayer_Implementation(FUniqueNetIdRepl PlayerId) { NativeCall<void, FUniqueNetIdRepl>(this, "APlayerController.ClientMutePlayer_Implementation", PlayerId); }
    void ClientUnmutePlayer_Implementation(FUniqueNetIdRepl PlayerId) { NativeCall<void, FUniqueNetIdRepl>(this, "APlayerController.ClientUnmutePlayer_Implementation", PlayerId); }
    bool IsPlayerMuted(FUniqueNetId* PlayerId) { return NativeCall<bool, FUniqueNetId*>(this, "APlayerController.IsPlayerMuted", PlayerId); }
    bool IsPlayerMuted(FString* VivoxUsername) { return NativeCall<bool, FString*>(this, "APlayerController.IsPlayerMuted", VivoxUsername); }
    bool ShouldReplicateVoicePacketFrom(FUniqueNetId* Sender, char ShouldUseSuperRange, char* PlaybackFlags) { return NativeCall<bool, FUniqueNetId*, char, char*>(this, "APlayerController.ShouldReplicateVoicePacketFrom", Sender, ShouldUseSuperRange, PlaybackFlags); }
    void ClientWasKicked_Implementation(FText* KickReason) { NativeCall<void, FText*>(this, "APlayerController.ClientWasKicked_Implementation", KickReason); }
    bool IsPrimaryPlayer() { return NativeCall<bool>(this, "APlayerController.IsPrimaryPlayer"); }
    bool IsSplitscreenPlayer(int* OutSplitscreenPlayerIndex) { return NativeCall<bool, int*>(this, "APlayerController.IsSplitscreenPlayer", 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", Material, ForceDuration, CinematicTextureGroups); }
    void ClientPrestreamTextures_Implementation(AActor* ForcedActor, float ForceDuration, bool bEnableStreaming, int CinematicTextureGroups) { NativeCall<void, AActor*, float, bool, int>(this, "APlayerController.ClientPrestreamTextures_Implementation", ForcedActor, ForceDuration, bEnableStreaming, CinematicTextureGroups); }
    void ProcessForceFeedback(const float DeltaTime, const bool bGamePaused) { NativeCall<void, const float, const bool>(this, "APlayerController.ProcessForceFeedback", DeltaTime, bGamePaused); }
    void ClientClearCameraLensEffects_Implementation() { NativeCall<void>(this, "APlayerController.ClientClearCameraLensEffects_Implementation"); }
    void ReceivedSpectatorClass(TSubclassOf<AGameMode> SpectatorClass) { NativeCall<void, TSubclassOf<AGameMode>>(this, "APlayerController.ReceivedSpectatorClass", SpectatorClass); }
    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "APlayerController.GetLifetimeReplicatedProps", OutLifetimeProps); }
    void SetPawn(APawn* InPawn) { NativeCall<void, APawn*>(this, "APlayerController.SetPawn", InPawn); }
    void ClientNetGUIDActorDeletion_Implementation(FNetworkGUID TheNetGUID) { NativeCall<void, FNetworkGUID>(this, "APlayerController.ClientNetGUIDActorDeletion_Implementation", TheNetGUID); }
    void SetPlayer(UPlayer* InPlayer) { NativeCall<void, UPlayer*>(this, "APlayerController.SetPlayer", InPlayer); }
    void TickPlayerInput(const float DeltaSeconds, const bool bGamePaused) { NativeCall<void, const float, const bool>(this, "APlayerController.TickPlayerInput", DeltaSeconds, bGamePaused); }
    bool IsNetRelevantFor(APlayerController* RealViewer, AActor* Viewer, FVector* SrcLocation) { return NativeCall<bool, APlayerController*, AActor*, FVector*>(this, "APlayerController.IsNetRelevantFor", RealViewer, Viewer, SrcLocation); }
    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", 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", NewState); }
    void EndSpectatingState() { NativeCall<void>(this, "APlayerController.EndSpectatingState"); }
    void BeginInactiveState() { NativeCall<void>(this, "APlayerController.BeginInactiveState"); }
    void AddPitchInput(float Val) { NativeCall<void, float>(this, "APlayerController.AddPitchInput", Val); }
    void AddYawInput(float Val) { NativeCall<void, float>(this, "APlayerController.AddYawInput", Val); }
    void AddRollInput(float Val) { NativeCall<void, float>(this, "APlayerController.AddRollInput", Val); }
    bool IsInputKeyDown(FKey Key) { return NativeCall<bool, FKey>(this, "APlayerController.IsInputKeyDown", Key); }
    bool WasInputKeyJustPressed(FKey Key) { return NativeCall<bool, FKey>(this, "APlayerController.WasInputKeyJustPressed", Key); }
    bool WasInputKeyJustReleased(FKey Key) { return NativeCall<bool, FKey>(this, "APlayerController.WasInputKeyJustReleased", Key); }
    float GetInputAnalogKeyState(FKey Key) { return NativeCall<float, FKey>(this, "APlayerController.GetInputAnalogKeyState", Key); }
    FVector* GetInputVectorKeyState(FVector* result, FKey Key) { return NativeCall<FVector*, FVector*, FKey>(this, "APlayerController.GetInputVectorKeyState", result, Key); }
    void GetInputMotionState(FVector* Tilt, FVector* RotationRate, FVector* Gravity, FVector* Acceleration) { NativeCall<void, FVector*, FVector*, FVector*, FVector*>(this, "APlayerController.GetInputMotionState", Tilt, RotationRate, Gravity, Acceleration); }
    float GetInputKeyTimeDown(FKey Key) { return NativeCall<float, FKey>(this, "APlayerController.GetInputKeyTimeDown", Key); }
    bool GetMousePosition(float* LocationX, float* LocationY) { return NativeCall<bool, float*, float*>(this, "APlayerController.GetMousePosition", LocationX, LocationY); }
    void GetInputMouseDelta(float* DeltaX, float* DeltaY) { NativeCall<void, float*, float*>(this, "APlayerController.GetInputMouseDelta", DeltaX, DeltaY); }
    void EnableInput(APlayerController* PlayerController) { NativeCall<void, APlayerController*>(this, "APlayerController.EnableInput", PlayerController); }
    void DisableInput(APlayerController* PlayerController) { NativeCall<void, APlayerController*>(this, "APlayerController.DisableInput", PlayerController); }
    void SetVirtualJoystickVisibility(bool bVisible) { NativeCall<void, bool>(this, "APlayerController.SetVirtualJoystickVisibility", bVisible); }
    void UpdateCameraManager(float DeltaSeconds) { NativeCall<void, float>(this, "APlayerController.UpdateCameraManager", DeltaSeconds); }
    void ClientRepObjRef_Implementation(UObject* Object) { NativeCall<void, UObject*>(this, "APlayerController.ClientRepObjRef_Implementation", Object); }
    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, "APlayerController.NetSpawnActorAtLocation_Implementation", AnActorClass, AtLocation, AtRotation, attachToComponent, dataIndex, attachSocketName); }
    void ServerReceivedPlayerControllerAck_Implementation() { NativeCall<void>(this, "APlayerController.ServerReceivedPlayerControllerAck_Implementation"); }
    void ClientProcessNetExecCommandUnreliable_Implementation(AActor* ForActor, FName CommandName, FNetExecParams ExecParams) { NativeCall<void, AActor*, FName, FNetExecParams>(this, "APlayerController.ClientProcessNetExecCommandUnreliable_Implementation", ForActor, CommandName, ExecParams); }
    bool NetConnectionHasActiveActor(AActor* AnActor) { return NativeCall<bool, AActor*>(this, "APlayerController.NetConnectionHasActiveActor", AnActor); }
    void ClientProcessSimpleNetExecCommandBP_Implementation(AActor* ForActor, FName CommandName) { NativeCall<void, AActor*, FName>(this, "APlayerController.ClientProcessSimpleNetExecCommandBP_Implementation", ForActor, CommandName); }
    void ClientProcessSimpleNetExecCommandUnreliableBP_Implementation(AActor* ForActor, FName CommandName) { NativeCall<void, AActor*, FName>(this, "APlayerController.ClientProcessSimpleNetExecCommandUnreliableBP_Implementation", ForActor, CommandName); }
    static void StaticRegisterNativesAPlayerController() { NativeCall<void>(nullptr, "APlayerController.StaticRegisterNativesAPlayerController"); }
    void ClientClearCameraLensEffects() { NativeCall<void>(this, "APlayerController.ClientClearCameraLensEffects"); }
    void ClientCommitMapChange() { NativeCall<void>(this, "APlayerController.ClientCommitMapChange"); }
    void ClientEnableNetworkVoice(bool bEnable) { NativeCall<void, bool>(this, "APlayerController.ClientEnableNetworkVoice", bEnable); }
    void ClientGotoState(FName NewState) { NativeCall<void, FName>(this, "APlayerController.ClientGotoState", NewState); }
    void ClientMessage(FString* S, FName Type, float MsgLifeTime) { NativeCall<void, FString*, FName, float>(this, "APlayerController.ClientMessage", S, Type, MsgLifeTime); }
    void ClientMutePlayer(FUniqueNetIdRepl PlayerId) { NativeCall<void, FUniqueNetIdRepl>(this, "APlayerController.ClientMutePlayer", PlayerId); }
    void ClientRepObjRef(UObject* Object) { NativeCall<void, UObject*>(this, "APlayerController.ClientRepObjRef", Object); }
    void ClientRetryClientRestart(APawn* NewPawn) { NativeCall<void, APawn*>(this, "APlayerController.ClientRetryClientRestart", NewPawn); }
    void ClientReturnToMainMenu(FString* ReturnReason) { NativeCall<void, FString*>(this, "APlayerController.ClientReturnToMainMenu", ReturnReason); }
    void ClientSetHUD(TSubclassOf<AHUD> NewHUDClass) { NativeCall<void, TSubclassOf<AHUD>>(this, "APlayerController.ClientSetHUD", NewHUDClass); }
    void ClientTeamMessage(APlayerState* SenderPlayerState, FString* S, FName Type, float MsgLifeTime) { NativeCall<void, APlayerState*, FString*, FName, float>(this, "APlayerController.ClientTeamMessage", SenderPlayerState, S, Type, MsgLifeTime); }
    void ClientUnmutePlayer(FUniqueNetIdRepl PlayerId) { NativeCall<void, FUniqueNetIdRepl>(this, "APlayerController.ClientUnmutePlayer", PlayerId); }
    void ClientVoiceHandshakeComplete() { NativeCall<void>(this, "APlayerController.ClientVoiceHandshakeComplete"); }
    void ClientWasKicked(FText* KickReason) { NativeCall<void, FText*>(this, "APlayerController.ClientWasKicked", KickReason); }
    void ServerChangeName(FString* S) { NativeCall<void, FString*>(this, "APlayerController.ServerChangeName", S); }
    void ServerMutePlayer(FUniqueNetIdRepl PlayerId) { NativeCall<void, FUniqueNetIdRepl>(this, "APlayerController.ServerMutePlayer", PlayerId); }
    void ServerRestartPlayer() { NativeCall<void>(this, "APlayerController.ServerRestartPlayer"); }
    void ServerUnmutePlayer(FUniqueNetIdRepl PlayerId) { NativeCall<void, FUniqueNetIdRepl>(this, "APlayerController.ServerUnmutePlayer", PlayerId); }
    void ServerVerifyViewTarget() { NativeCall<void>(this, "APlayerController.ServerVerifyViewTarget"); }
};
 
struct ABasePlayerController : APlayerController
{
    FName& ServerSayStringField() { return *GetNativePointerField<FName*>(this, "ABasePlayerController.ServerSayString"); }
    bool& bHasSentStartEventsField() { return *GetNativePointerField<bool*>(this, "ABasePlayerController.bHasSentStartEvents"); }
 
    // Bit fields
 
    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 OnQueryAchievementsComplete(FUniqueNetId* PlayerId, const bool bWasSuccessful) { NativeCall<void, FUniqueNetId*, const bool>(this, "ABasePlayerController.OnQueryAchievementsComplete", PlayerId, bWasSuccessful); }
    void GameHasEnded(AActor* EndGameFocus, bool bIsWinner) { NativeCall<void, AActor*, bool>(this, "ABasePlayerController.GameHasEnded", EndGameFocus, bIsWinner); }
    void SimulateInputKey(FKey Key, bool bPressed) { NativeCall<void, FKey, bool>(this, "ABasePlayerController.SimulateInputKey", Key, bPressed); }
    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(FString* ReturnReason) { NativeCall<void, FString*>(this, "ABasePlayerController.ClientReturnToMainMenu_Implementation", ReturnReason); }
    void CleanupSessionOnReturnToMenu() { NativeCall<void>(this, "ABasePlayerController.CleanupSessionOnReturnToMenu"); }
    void ClientGameEnded_Implementation(AActor* EndGameFocus, bool bIsWinner) { NativeCall<void, AActor*, bool>(this, "ABasePlayerController.ClientGameEnded_Implementation", EndGameFocus, bIsWinner); }
    void ClientSendRoundEndEvent_Implementation(bool bIsWinner, int ExpendedTimeInSeconds) { NativeCall<void, bool, int>(this, "ABasePlayerController.ClientSendRoundEndEvent_Implementation", bIsWinner, ExpendedTimeInSeconds); }
    void ClientSetSpectatorCamera_Implementation(FVector CameraLocation, FRotator CameraRotation) { NativeCall<void, FVector, FRotator>(this, "ABasePlayerController.ClientSetSpectatorCamera_Implementation", CameraLocation, CameraRotation); }
    void ServerCheat_Implementation(FString* Msg) { NativeCall<void, FString*>(this, "ABasePlayerController.ServerCheat_Implementation", 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"); }
    static void StaticRegisterNativesABasePlayerController() { NativeCall<void>(nullptr, "ABasePlayerController.StaticRegisterNativesABasePlayerController"); }
    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "ABasePlayerController.GetPrivateStaticClass", Package); }
    void ClientEndOnlineGame() { NativeCall<void>(this, "ABasePlayerController.ClientEndOnlineGame"); }
    void ClientGameStarted() { NativeCall<void>(this, "ABasePlayerController.ClientGameStarted"); }
    void ClientSendRoundEndEvent(bool bIsWinner, int ExpendedTimeInSeconds) { NativeCall<void, bool, int>(this, "ABasePlayerController.ClientSendRoundEndEvent", bIsWinner, ExpendedTimeInSeconds); }
    void ClientSetSpectatorCamera(FVector CameraLocation, FRotator CameraRotation) { NativeCall<void, FVector, FRotator>(this, "ABasePlayerController.ClientSetSpectatorCamera", CameraLocation, CameraRotation); }
    void ClientStartOnlineGame() { NativeCall<void>(this, "ABasePlayerController.ClientStartOnlineGame"); }
    void ServerCheat(FString* Msg) { NativeCall<void, FString*>(this, "ABasePlayerController.ServerCheat", Msg); }
    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "ABasePlayerController.StaticClass"); }
};
 
struct AShooterPlayerController : ABasePlayerController
{
    FieldArray<char, 10> HeldItemSlotField() { return { this, "AShooterPlayerController.HeldItemSlot" }; }
    FieldArray<char, 10> UsedItemSlotField() { return { this, "AShooterPlayerController.UsedItemSlot" }; }
    FieldArray<long double, 10> LastRepeatUseConsumableTimeField() { return { this, "AShooterPlayerController.LastRepeatUseConsumableTime" }; }
    FieldArray<long double, 10> HeldItemSlotTimeField() { return { this, "AShooterPlayerController.HeldItemSlotTime" }; }
    FieldArray<long double, 10> LastUsedItemSlotTimesField() { return { this, "AShooterPlayerController.LastUsedItemSlotTimes" }; }
    FVector& CurrentPlayerCharacterLocationField() { return *GetNativePointerField<FVector*>(this, "AShooterPlayerController.CurrentPlayerCharacterLocation"); }
    int& ModifedButtonCountField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.ModifedButtonCount"); }
    int& nArkTributeLoadIndexField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.nArkTributeLoadIndex"); }
    APrimalStructurePlacer* StructurePlacerField() { return *GetNativePointerField<APrimalStructurePlacer**>(this, "AShooterPlayerController.StructurePlacer"); }
    FVector& LastDeathLocationField() { return *GetNativePointerField<FVector*>(this, "AShooterPlayerController.LastDeathLocation"); }
    long double& LastDeathTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastDeathTime"); }
    TWeakObjectPtr<APrimalCharacter>& LastDeathPrimalCharacterField() { return *GetNativePointerField<TWeakObjectPtr<APrimalCharacter>*>(this, "AShooterPlayerController.LastDeathPrimalCharacter"); }
    bool& bWasDeadField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bWasDead"); }
    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"); }
    FVector2D& CurrentRadialDirection1Field() { return *GetNativePointerField<FVector2D*>(this, "AShooterPlayerController.CurrentRadialDirection1"); }
    FVector2D& CurrentRadialDirection2Field() { return *GetNativePointerField<FVector2D*>(this, "AShooterPlayerController.CurrentRadialDirection2"); }
    USoundCue* SelectSlotSoundField() { return *GetNativePointerField<USoundCue**>(this, "AShooterPlayerController.SelectSlotSound"); }
    UPrimalLocalProfile* PrimalLocalProfileField() { return *GetNativePointerField<UPrimalLocalProfile**>(this, "AShooterPlayerController.PrimalLocalProfile"); }
    int& CurrentGameModeMaxNumOfRespawnsField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.CurrentGameModeMaxNumOfRespawns"); }
    FVector& LastRawInputDirField() { return *GetNativePointerField<FVector*>(this, "AShooterPlayerController.LastRawInputDir"); }
    FString& VivoxUsernameField() { return *GetNativePointerField<FString*>(this, "AShooterPlayerController.VivoxUsername"); }
    int& VivoxLoginAttemptsField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.VivoxLoginAttempts"); }
    int& VivoxJoinChannelAttemptsField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.VivoxJoinChannelAttempts"); }
    TMap<enum AtlasVoiceChannelType, FString, FDefaultSetAllocator, TDefaultMapKeyFuncs<enum AtlasVoiceChannelType, FString, 0> >& ConnectedVoiceChannelsField() { return *GetNativePointerField<TMap<enum AtlasVoiceChannelType, FString, FDefaultSetAllocator, TDefaultMapKeyFuncs<enum AtlasVoiceChannelType, FString, 0> >*>(this, "AShooterPlayerController.ConnectedVoiceChannels"); }
    bool& bConnectedToPositionalChannelField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bConnectedToPositionalChannel"); }
    long double& LastVivoxPositionalUpdateField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastVivoxPositionalUpdate"); }
    unsigned __int64& TargetOrbitedPlayerIdField() { return *GetNativePointerField<unsigned __int64*>(this, "AShooterPlayerController.TargetOrbitedPlayerId"); }
    char& TargetOrbitedTrialCountField() { return *GetNativePointerField<char*>(this, "AShooterPlayerController.TargetOrbitedTrialCount"); }
    TWeakObjectPtr<AShooterCharacter>& LastControlledPlayerCharacterField() { return *GetNativePointerField<TWeakObjectPtr<AShooterCharacter>*>(this, "AShooterPlayerController.LastControlledPlayerCharacter"); }
    TSubclassOf<APrimalStructurePlacer>& StructurePlacerClassField() { return *GetNativePointerField<TSubclassOf<APrimalStructurePlacer>*>(this, "AShooterPlayerController.StructurePlacerClass"); }
    float& MaxUseDistanceField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.MaxUseDistance"); }
    float& MaxUseCheckRadiusField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.MaxUseCheckRadius"); }
    TArray<bool>& SavedSurvivorProfileSettingsField() { return *GetNativePointerField<TArray<bool>*>(this, "AShooterPlayerController.SavedSurvivorProfileSettings"); }
    bool& bCachedOnlyShowOnlineTribeMembersField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bCachedOnlyShowOnlineTribeMembers"); }
    int& SavedMissionBiomeFilterMaskField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.SavedMissionBiomeFilterMask"); }
    bool& bInitializedMissionUIField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bInitializedMissionUI"); }
    bool& bMissionSortByDistanceField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bMissionSortByDistance"); }
    TArray<FDinoMapMarkerInfo>& MapDinosField() { return *GetNativePointerField<TArray<FDinoMapMarkerInfo>*>(this, "AShooterPlayerController.MapDinos"); }
    TArray<TWeakObjectPtr<UPrimalInventoryComponent>>& RemoteViewingInventoriesField() { return *GetNativePointerField<TArray<TWeakObjectPtr<UPrimalInventoryComponent>>*>(this, "AShooterPlayerController.RemoteViewingInventories"); }
    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"); }
    bool& bUsePressedFromGamepadField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bUsePressedFromGamepad"); }
    TWeakObjectPtr<APrimalStructure>& SpawnAtBedField() { return *GetNativePointerField<TWeakObjectPtr<APrimalStructure>*>(this, "AShooterPlayerController.SpawnAtBed"); }
    APawn* TempLastLostPawnField() { return *GetNativePointerField<APawn**>(this, "AShooterPlayerController.TempLastLostPawn"); }
    bool& bHasLoadedProfileField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bHasLoadedProfile"); }
    bool& bLockedInputDontRecenterMouseField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bLockedInputDontRecenterMouse"); }
    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"); }
    __int64& LinkedPlayerIDField() { return *GetNativePointerField<__int64*>(this, "AShooterPlayerController.LinkedPlayerID"); }
    bool& bDrawLocationField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bDrawLocation"); }
    int& PlayerControllerNumField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.PlayerControllerNum"); }
    FVector& LastTurnSpeedField() { return *GetNativePointerField<FVector*>(this, "AShooterPlayerController.LastTurnSpeed"); }
    long double& LastMultiUseInteractionTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastMultiUseInteractionTime"); }
    float& LastTimeSentCarriedRotationField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.LastTimeSentCarriedRotation"); }
    TMap<FGuid, FARKTributeData, FDefaultSetAllocator, TDefaultMapKeyFuncs<FGuid, FARKTributeData, 0> >& LastArkTributeDataField() { return *GetNativePointerField<TMap<FGuid, FARKTributeData, FDefaultSetAllocator, TDefaultMapKeyFuncs<FGuid, FARKTributeData, 0> >*>(this, "AShooterPlayerController.LastArkTributeData"); }
    FItemNetID& LastSteamItemIDToRemoveField() { return *GetNativePointerField<FItemNetID*>(this, "AShooterPlayerController.LastSteamItemIDToRemove"); }
    FItemNetID& LastSteamItemIDToAddField() { return *GetNativePointerField<FItemNetID*>(this, "AShooterPlayerController.LastSteamItemIDToAdd"); }
    bool& bConsumeItemSucceededField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bConsumeItemSucceeded"); }
    bool& bRefreshedInvetoryForRemoveField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bRefreshedInvetoryForRemove"); }
    bool& bServerRefreshedSteamInventoryField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bServerRefreshedSteamInventory"); }
    bool& bServerRefreshStatusField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bServerRefreshStatus"); }
    bool& bCloseSteamStatusSceneField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bCloseSteamStatusScene"); }
    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& bServerIsPaintingField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bServerIsPainting"); }
    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& bPossessedAnyPawnField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bPossessedAnyPawn"); }
    bool& bIsFastTravellingField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bIsFastTravelling"); }
    bool& bLastSpawnWasFastTravelField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bLastSpawnWasFastTravel"); }
    bool& bSuppressAdminIconField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bSuppressAdminIcon"); }
    long double& WaitingForSpawnUITimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.WaitingForSpawnUITime"); }
    float& ChatSpamWeightField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ChatSpamWeight"); }
    bool& bChatSpammedField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bChatSpammed"); }
    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"); }
    TArray<int>& PlayerAppIDsField() { return *GetNativePointerField<TArray<int>*>(this, "AShooterPlayerController.PlayerAppIDs"); }
    TArray<int>& NotifiedTribeWarIDsField() { return *GetNativePointerField<TArray<int>*>(this, "AShooterPlayerController.NotifiedTribeWarIDs"); }
    TArray<FString>& NotifiedTribeWarNamesField() { return *GetNativePointerField<TArray<FString>*>(this, "AShooterPlayerController.NotifiedTribeWarNames"); }
    int& ServerTribeLogLastLogIndexField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.ServerTribeLogLastLogIndex"); }
    int& ServerTribeLogLastTribeIDField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.ServerTribeLogLastTribeID"); }
    FVector& LastViewLocationField() { return *GetNativePointerField<FVector*>(this, "AShooterPlayerController.LastViewLocation"); }
    bool& bHasGottenInitialSpawnLocationField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bHasGottenInitialSpawnLocation"); }
    bool& bClientReceivedTribeLogField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bClientReceivedTribeLog"); }
    TArray<FString>& CurrentTribeLogField() { return *GetNativePointerField<TArray<FString>*>(this, "AShooterPlayerController.CurrentTribeLog"); }
    long double& LastTribeLogRequestTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastTribeLogRequestTime"); }
    bool& bHasSurvivedOneDayField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bHasSurvivedOneDay"); }
    bool& bHasReachedHighestPeakField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bHasReachedHighestPeak"); }
    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& bZoomingOutField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bZoomingOut"); }
    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"); }
    FVector& LastLargeMoveLocationField() { return *GetNativePointerField<FVector*>(this, "AShooterPlayerController.LastLargeMoveLocation"); }
    long double& LastLargeMoveTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastLargeMoveTime"); }
    long double& LastNotOnUnriddenDinoTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastNotOnUnriddenDinoTime"); }
    long double& LastHitMarkerCharacterTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastHitMarkerCharacterTime"); }
    bool& bLastHitMarkerCharacterAllyField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bLastHitMarkerCharacterAlly"); }
    long double& LastHitMarkerStructureTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastHitMarkerStructureTime"); }
    bool& bLastHitMarkerStructureAllyField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bLastHitMarkerStructureAlly"); }
    float& DoFSettingCurrentTimerField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.DoFSettingCurrentTimer"); }
    float& DoFSettingTargetTimerField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.DoFSettingTargetTimer"); }
    TArray<FSteamInventoryItemInfo>& PlayerInventoryItemsField() { return *GetNativePointerField<TArray<FSteamInventoryItemInfo>*>(this, "AShooterPlayerController.PlayerInventoryItems"); }
    int& LastSpawnPointIDField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.LastSpawnPointID"); }
    int& LastSpawnRegionIndexField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.LastSpawnRegionIndex"); }
    unsigned __int64& LastTransferredPlayerIDField() { return *GetNativePointerField<unsigned __int64*>(this, "AShooterPlayerController.LastTransferredPlayerID"); }
    bool& bReceivedSubscribedAppsField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bReceivedSubscribedApps"); }
    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"); }
    FVector& LastSnapPointCyclePositionField() { return *GetNativePointerField<FVector*>(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"); }
    int& PersonalDinoTameCountField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.PersonalDinoTameCount"); }
    bool& bNextShowCharacterCreationUIDownloadField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bNextShowCharacterCreationUIDownload"); }
    bool& bForceHideGameplayUIField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bForceHideGameplayUI"); }
    long double& LastGamepadOpenRemoteInventoryTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastGamepadOpenRemoteInventoryTime"); }
    bool& bIsGamepadActiveField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bIsGamepadActive"); }
    bool& bClientIsDPCField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bClientIsDPC"); }
    long double& LastClientRequestTribeOnlineListTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastClientRequestTribeOnlineListTime"); }
    long double& LastClientModifiedARKInventoryTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastClientModifiedARKInventoryTime"); }
    TArray<unsigned __int64>& ClientCachedTribeOnlineListField() { return *GetNativePointerField<TArray<unsigned __int64>*>(this, "AShooterPlayerController.ClientCachedTribeOnlineList"); }
    bool& bPreventDefaultCharacterItemsField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bPreventDefaultCharacterItems"); }
    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"); }
    bool& bHasDisplayedSplitScreenMessageField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bHasDisplayedSplitScreenMessage"); }
    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& bIsViewingTributeInventoryField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bIsViewingTributeInventory"); }
    bool& bDrawBlackBackgroundField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bDrawBlackBackground"); }
    bool& bFailedToDownloadedTransferredCharacterField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bFailedToDownloadedTransferredCharacter"); }
    TSubclassOf<APrimalBuff>& CreativeModeBuffField() { return *GetNativePointerField<TSubclassOf<APrimalBuff>*>(this, "AShooterPlayerController.CreativeModeBuff"); }
    float& PrimalStatsCacheFlushIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.PrimalStatsCacheFlushInterval"); }
    bool& bIsPrimalStatsTimerActiveField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bIsPrimalStatsTimerActive"); }
    bool& bAutoPlayerField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bAutoPlayer"); }
    float& PingTraceDistanceField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.PingTraceDistance"); }
    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"); }
    float& PingCoolDownTimeField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.PingCoolDownTime"); }
    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"); }
    long double& LastPingTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastPingTime"); }
    TArray<FPingData>& CurrentPingsField() { return *GetNativePointerField<TArray<FPingData>*>(this, "AShooterPlayerController.CurrentPings"); }
    bool& bDebugPOIsField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bDebugPOIs"); }
    float& POI_SearchTickInterval_CurrentField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.POI_SearchTickInterval_Current"); }
    FVector2D& POI_SearchTickInterval_RandRangesField() { return *GetNativePointerField<FVector2D*>(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*> SpawnedPointWidgetsField() { return *GetNativePointerField<TArray<UUserWidget*>*>(this, "AShooterPlayerController.SpawnedPointWidgets"); }
    TArray<APointOfInterestCosmeticActor*> SpawnedPointCosmeticActorsField() { return *GetNativePointerField<TArray<APointOfInterestCosmeticActor*>*>(this, "AShooterPlayerController.SpawnedPointCosmeticActors"); }
    TArray<FPointOfInterestData_ForCompanion>& NearbyPointsOfInterestField() { return *GetNativePointerField<TArray<FPointOfInterestData_ForCompanion>*>(this, "AShooterPlayerController.NearbyPointsOfInterest"); }
    FMissionWaypointInfo& MissionWaypointField() { return *GetNativePointerField<FMissionWaypointInfo*>(this, "AShooterPlayerController.MissionWaypoint"); }
 
    // Bit fields
 
    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> bUsePressed() { return { this, "AShooterPlayerController.bUsePressed" }; }
    BitFieldValue<bool, unsigned __int32> bForceCraftButtonHeld() { return { this, "AShooterPlayerController.bForceCraftButtonHeld" }; }
    BitFieldValue<bool, unsigned __int32> bGamepadHotbarModifierPressed() { return { this, "AShooterPlayerController.bGamepadHotbarModifierPressed" }; }
    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> bWantsToPing() { return { this, "AShooterPlayerController.bWantsToPing" }; }
    BitFieldValue<bool, unsigned __int32> bEnablePingSystem() { return { this, "AShooterPlayerController.bEnablePingSystem" }; }
    BitFieldValue<bool, unsigned __int32> bWasGamepadHotbarModifierPressed_RightShoulder() { return { this, "AShooterPlayerController.bWasGamepadHotbarModifierPressed_RightShoulder" }; }
 
    // Functions
 
    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "AShooterPlayerController.GetPrivateStaticClass"); }
    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "AShooterPlayerController.StaticClass"); }
    bool IsGameMenuVisible() { return NativeCall<bool>(this, "AShooterPlayerController.IsGameMenuVisible"); }
    void EnableCheats(FString Pass) { NativeCall<void, FString>(this, "AShooterPlayerController.EnableCheats", Pass); }
    void CheckCheatsPassword_Implementation(FString* Pass) { NativeCall<void, FString*>(this, "AShooterPlayerController.CheckCheatsPassword_Implementation", Pass); }
    void AutoCycle(float Duration) { NativeCall<void, float>(this, "AShooterPlayerController.AutoCycle", Duration); }
    void RequestSpectator(FString InSpectatorPass) { NativeCall<void, FString>(this, "AShooterPlayerController.RequestSpectator", InSpectatorPass); }
    void CheckRequestSpectator_Implementation(FString* InSpectatorPass) { NativeCall<void, FString*>(this, "AShooterPlayerController.CheckRequestSpectator_Implementation", InSpectatorPass); }
    void StopSpectating() { NativeCall<void>(this, "AShooterPlayerController.StopSpectating"); }
    void ServerStopSpectating_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerStopSpectating_Implementation"); }
    TArray<FString>* GetCheatsCommands(TArray<FString>* result) { return NativeCall<TArray<FString>*, TArray<FString>*>(this, "AShooterPlayerController.GetCheatsCommands", result); }
    void SetupInputComponent() { NativeCall<void>(this, "AShooterPlayerController.SetupInputComponent"); }
    void OnLevelView() { NativeCall<void>(this, "AShooterPlayerController.OnLevelView"); }
    void LevelView() { NativeCall<void>(this, "AShooterPlayerController.LevelView"); }
    void SpectatorDetachOrbitCamera() { NativeCall<void>(this, "AShooterPlayerController.SpectatorDetachOrbitCamera"); }
    void SpectatorPreviousPlayer() { NativeCall<void>(this, "AShooterPlayerController.SpectatorPreviousPlayer"); }
    void SpectatorNextPlayer() { NativeCall<void>(this, "AShooterPlayerController.SpectatorNextPlayer"); }
    void DelayedTeamSpectatorSetup() { NativeCall<void>(this, "AShooterPlayerController.DelayedTeamSpectatorSetup"); }
    void ServerCycleSpectator_Implementation(bool bNext) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerCycleSpectator_Implementation", bNext); }
    void ServerSpectateToPlayerByID_Implementation(unsigned __int64 PlayerID) { NativeCall<void, unsigned __int64>(this, "AShooterPlayerController.ServerSpectateToPlayerByID_Implementation", PlayerID); }
    void ClientTeleportSpectator_Implementation(FVector Location, unsigned __int64 PlayerID) { NativeCall<void, FVector, unsigned __int64>(this, "AShooterPlayerController.ClientTeleportSpectator_Implementation", Location, PlayerID); }
    void ForceCraftPressed() { NativeCall<void>(this, "AShooterPlayerController.ForceCraftPressed"); }
    void ForceCraftReleased() { NativeCall<void>(this, "AShooterPlayerController.ForceCraftReleased"); }
    void StartWhispering() { NativeCall<void>(this, "AShooterPlayerController.StartWhispering"); }
    void StartYelling() { NativeCall<void>(this, "AShooterPlayerController.StartYelling"); }
    void StartTalkingWrapper() { NativeCall<void>(this, "AShooterPlayerController.StartTalkingWrapper"); }
    void StopTalkingWrapper() { NativeCall<void>(this, "AShooterPlayerController.StopTalkingWrapper"); }
    void ToggleHUDHidden() { NativeCall<void>(this, "AShooterPlayerController.ToggleHUDHidden"); }
    void OnUseItemSlotForStructure(int ItemSlotNumber) { NativeCall<void, int>(this, "AShooterPlayerController.OnUseItemSlotForStructure", ItemSlotNumber); }
    void OnUsePress(bool bFromGamepad) { NativeCall<void, bool>(this, "AShooterPlayerController.OnUsePress", bFromGamepad); }
    bool GetAllAimedHarvestActors(float MaxDistance, TArray<AActor*>* OutHarvestActors, TArray<UActorComponent*>* OutHarvestComponents, TArray<int>* OutHitBodyIndices) { return NativeCall<bool, float, TArray<AActor*>*, TArray<UActorComponent*>*, TArray<int>*>(this, "AShooterPlayerController.GetAllAimedHarvestActors", MaxDistance, OutHarvestActors, OutHarvestComponents, OutHitBodyIndices); }
    AActor* GetAimedUseActor(UActorComponent** UseComponent, int* hitBodyIndex, bool bForceUseActorLocation) { return NativeCall<AActor*, UActorComponent**, int*, bool>(this, "AShooterPlayerController.GetAimedUseActor", UseComponent, hitBodyIndex, bForceUseActorLocation); }
    void OnUseRelease(bool bFromGamepad) { NativeCall<void, bool>(this, "AShooterPlayerController.OnUseRelease", bFromGamepad); }
    void ActivateMultiUseSelection(bool bIsFromUseRelease) { NativeCall<void, bool>(this, "AShooterPlayerController.ActivateMultiUseSelection", 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) { NativeCall<void, int>(this, "AShooterPlayerController.SetMultiUseWheelCategory", Category); }
    void StartInventoryRadialSelector() { NativeCall<void>(this, "AShooterPlayerController.StartInventoryRadialSelector"); }
    void EndInventoryRadialSelector() { NativeCall<void>(this, "AShooterPlayerController.EndInventoryRadialSelector"); }
    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", Index); }
    void LoadSpectatorPos(int Index) { NativeCall<void, int>(this, "AShooterPlayerController.LoadSpectatorPos", 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() { NativeCall<void>(this, "AShooterPlayerController.EndWhistleSelection"); }
    void EndEmoteSelection() { NativeCall<void>(this, "AShooterPlayerController.EndEmoteSelection"); }
    void TriggerPlayerAction(int ActionIndex) { NativeCall<void, int>(this, "AShooterPlayerController.TriggerPlayerAction", ActionIndex); }
    void ShowMyInventory() { NativeCall<void>(this, "AShooterPlayerController.ShowMyInventory"); }
    void ShowMyAdminManager() { NativeCall<void>(this, "AShooterPlayerController.ShowMyAdminManager"); }
    void ShowMyCraftables() { NativeCall<void>(this, "AShooterPlayerController.ShowMyCraftables"); }
    void ShowTribeManager() { NativeCall<void>(this, "AShooterPlayerController.ShowTribeManager"); }
    void ShowGlobalChat() { NativeCall<void>(this, "AShooterPlayerController.ShowGlobalChat"); }
    void ShowTribeChat() { NativeCall<void>(this, "AShooterPlayerController.ShowTribeChat"); }
    void ShowAllianceChat() { NativeCall<void>(this, "AShooterPlayerController.ShowAllianceChat"); }
    void ShowLocalChat() { NativeCall<void>(this, "AShooterPlayerController.ShowLocalChat"); }
    void ShowTutorial(int TutorialIndex, bool bForceDisplay) { NativeCall<void, int, bool>(this, "AShooterPlayerController.ShowTutorial", TutorialIndex, bForceDisplay); }
    void HideTutorial(int TutorialIndex) { NativeCall<void, int>(this, "AShooterPlayerController.HideTutorial", 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 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 SaveProfile() { NativeCall<void>(this, "AShooterPlayerController.SaveProfile"); }
    void LoadProfile(bool ForceReload) { NativeCall<void, bool>(this, "AShooterPlayerController.LoadProfile", ForceReload); }
    void ClientNotifyPaintFinished_Implementation(bool bSuccess) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientNotifyPaintFinished_Implementation", bSuccess); }
    bool IsValidUnStasisCaster() { return NativeCall<bool>(this, "AShooterPlayerController.IsValidUnStasisCaster"); }
    bool SameLinkedId(__int64 value) { return NativeCall<bool, __int64>(this, "AShooterPlayerController.SameLinkedId", value); }
    void ServerSetSpectatorLocation_Implementation(FVector NewLoc) { NativeCall<void, FVector>(this, "AShooterPlayerController.ServerSetSpectatorLocation_Implementation", NewLoc); }
    static void TickStasisForCharacter(UWorld* theWorld, APrimalCharacter* Character, FVector ActorLocation) { NativeCall<void, UWorld*, APrimalCharacter*, FVector>(nullptr, "AShooterPlayerController.TickStasisForCharacter", theWorld, Character, ActorLocation); }
    void SetPlayer(UPlayer* InPlayer) { NativeCall<void, UPlayer*>(this, "AShooterPlayerController.SetPlayer", 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() { NativeCall<void>(this, "AShooterPlayerController.EnableSpectator"); }
    void DisableSpectator() { NativeCall<void>(this, "AShooterPlayerController.DisableSpectator"); }
    void OnDisableSpectator_Implementation() { NativeCall<void>(this, "AShooterPlayerController.OnDisableSpectator_Implementation"); }
    void CheckforOrbiting() { NativeCall<void>(this, "AShooterPlayerController.CheckforOrbiting"); }
    bool CheckforOrbitingInstantaneously() { return NativeCall<bool>(this, "AShooterPlayerController.CheckforOrbitingInstantaneously"); }
    void OnToggleInGameMenu() { NativeCall<void>(this, "AShooterPlayerController.OnToggleInGameMenu"); }
    void OnToggleDoFMenu() { NativeCall<void>(this, "AShooterPlayerController.OnToggleDoFMenu"); }
    void MoveForward(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.MoveForward", Val); }
    void MoveRight(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.MoveRight", Val); }
    void TurnAtRate(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.TurnAtRate", Val); }
    void LookUpAtRate(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.LookUpAtRate", Val); }
    void SpectatorTurn(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.SpectatorTurn", Val); }
    void TurnInput(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.TurnInput", Val); }
    void LookInput(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.LookInput", Val); }
    void BPClientUnlockExplorerNote(int ExplorerNoteIndex) { NativeCall<void, int>(this, "AShooterPlayerController.BPClientUnlockExplorerNote", ExplorerNoteIndex); }
    void OnStartFire() { NativeCall<void>(this, "AShooterPlayerController.OnStartFire"); }
    void OnStopFire() { NativeCall<void>(this, "AShooterPlayerController.OnStopFire"); }
    void OnStartGamepadRightFire() { NativeCall<void>(this, "AShooterPlayerController.OnStartGamepadRightFire"); }
    void OnStopGamepadRightFire() { NativeCall<void>(this, "AShooterPlayerController.OnStopGamepadRightFire"); }
    void ShowBattleGameModeHUD() { NativeCall<void>(this, "AShooterPlayerController.ShowBattleGameModeHUD"); }
    void OnStartTargeting() { NativeCall<void>(this, "AShooterPlayerController.OnStartTargeting"); }
    void OnStopTargeting() { NativeCall<void>(this, "AShooterPlayerController.OnStopTargeting"); }
    void OnStartGamepadLeftFire() { NativeCall<void>(this, "AShooterPlayerController.OnStartGamepadLeftFire"); }
    void OnStopGamepadLeftFire() { NativeCall<void>(this, "AShooterPlayerController.OnStopGamepadLeftFire"); }
    void ServerRequestPlaceStructure_Implementation(int StructureIndex, FVector BuildLocation, FRotator BuildRotation, FRotator PlayerViewRotation, APawn* AttachToPawn, APrimalDinoCharacter* DinoCharacter, FName BoneName, FItemNetID PlaceUsingItemID, bool bSnapped, bool bIsCheat, bool bIsFlipped, int SnapPointCycle) { NativeCall<void, int, FVector, FRotator, FRotator, APawn*, APrimalDinoCharacter*, FName, FItemNetID, bool, bool, bool, int>(this, "AShooterPlayerController.ServerRequestPlaceStructure_Implementation", StructureIndex, BuildLocation, BuildRotation, PlayerViewRotation, AttachToPawn, DinoCharacter, BoneName, PlaceUsingItemID, bSnapped, bIsCheat, bIsFlipped, SnapPointCycle); }
    void DebugStructures() { NativeCall<void>(this, "AShooterPlayerController.DebugStructures"); }
    void SetGodMode(bool bEnable) { NativeCall<void, bool>(this, "AShooterPlayerController.SetGodMode", bEnable); }
    void SetCinematicMode(bool bInCinematicMode, bool bHidePlayer, bool bAffectsHUD, bool bAffectsMovement, bool bAffectsTurning) { NativeCall<void, bool, bool, bool, bool, bool>(this, "AShooterPlayerController.SetCinematicMode", bInCinematicMode, bHidePlayer, bAffectsHUD, bAffectsMovement, bAffectsTurning); }
    void PawnLeavingGame() { NativeCall<void>(this, "AShooterPlayerController.PawnLeavingGame"); }
    void InitInputSystem() { NativeCall<void>(this, "AShooterPlayerController.InitInputSystem"); }
    void FlushPressedKeys() { NativeCall<void>(this, "AShooterPlayerController.FlushPressedKeys"); }
    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "AShooterPlayerController.GetLifetimeReplicatedProps", OutLifetimeProps); }
    void EnemyInVisible(bool Invisible) { NativeCall<void, bool>(this, "AShooterPlayerController.EnemyInVisible", Invisible); }
    bool HasGodMode() { return NativeCall<bool>(this, "AShooterPlayerController.HasGodMode"); }
    void ServerRemovePassenger_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerRemovePassenger_Implementation"); }
    void ClientTeamMessage_Implementation(APlayerState* SenderPlayerState, FString* S, FName Type, float MsgLifeTime) { NativeCall<void, APlayerState*, FString*, FName, float>(this, "AShooterPlayerController.ClientTeamMessage_Implementation", SenderPlayerState, S, Type, MsgLifeTime); }
    AShooterHUD* GetShooterHUD() { return NativeCall<AShooterHUD*>(this, "AShooterPlayerController.GetShooterHUD"); }
    void DrawHUD(AShooterHUD* HUD) { NativeCall<void, AShooterHUD*>(this, "AShooterPlayerController.DrawHUD", HUD); }
    UShooterPersistentUser* GetPersistentUser() { return NativeCall<UShooterPersistentUser*>(this, "AShooterPlayerController.GetPersistentUser"); }
    void ShowInGameMenu() { NativeCall<void>(this, "AShooterPlayerController.ShowInGameMenu"); }
    void SetControlRotation(FRotator* NewRotation) { NativeCall<void, FRotator*>(this, "AShooterPlayerController.SetControlRotation", NewRotation); }
    void AcknowledgePossession(APawn* P) { NativeCall<void, APawn*>(this, "AShooterPlayerController.AcknowledgePossession", 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", 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(FString* Message) { NativeCall<void, FString*>(this, "AShooterPlayerController.ClientGetMessageOfTheDay_Implementation", Message); }
    void ServerReadMessageOFTheDay_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerReadMessageOFTheDay_Implementation"); }
    void ClientStartReceivingActorItems_Implementation(UPrimalInventoryComponent* forInventory, bool bEquippedItems) { NativeCall<void, UPrimalInventoryComponent*, bool>(this, "AShooterPlayerController.ClientStartReceivingActorItems_Implementation", forInventory, bEquippedItems); }
    void ClientFinishedReceivingActorItems_Implementation(UPrimalInventoryComponent* forInventory, bool bEquippedItems) { NativeCall<void, UPrimalInventoryComponent*, bool>(this, "AShooterPlayerController.ClientFinishedReceivingActorItems_Implementation", forInventory, bEquippedItems); }
    void ClientAddActorItem_Implementation(UPrimalInventoryComponent* forInventory, FItemNetInfo itemInfo, bool bEquipItem, bool ShowHUDNotification) { NativeCall<void, UPrimalInventoryComponent*, FItemNetInfo, bool, bool>(this, "AShooterPlayerController.ClientAddActorItem_Implementation", forInventory, itemInfo, bEquipItem, ShowHUDNotification); }
    void ClientAddActorItemToFolder_Implementation(UPrimalInventoryComponent* forInventory, FItemNetInfo itemInfo, bool bEquipItem, bool ShowHUDNotification, FString* ToFolder) { NativeCall<void, UPrimalInventoryComponent*, FItemNetInfo, bool, bool, FString*>(this, "AShooterPlayerController.ClientAddActorItemToFolder_Implementation", forInventory, itemInfo, bEquipItem, ShowHUDNotification, ToFolder); }
    void ClientAddItemToArk_Implementation(UPrimalInventoryComponent* forInventory, FItemNetInfo itemInfo, bool bFromLoad) { NativeCall<void, UPrimalInventoryComponent*, FItemNetInfo, bool>(this, "AShooterPlayerController.ClientAddItemToArk_Implementation", forInventory, itemInfo, bFromLoad); }
    void ClientAddFolderToInventoryComponent_Implementation(UPrimalInventoryComponent* forInventory, FString* NewCustomFolderName, int InventoryCompType) { NativeCall<void, UPrimalInventoryComponent*, FString*, int>(this, "AShooterPlayerController.ClientAddFolderToInventoryComponent_Implementation", forInventory, NewCustomFolderName, InventoryCompType); }
    void ClientLoadArkItems_Implementation(UPrimalInventoryComponent* forInventory, TArray<FItemNetInfo>* itemInfos, bool bClear, bool bFinalBatch) { NativeCall<void, UPrimalInventoryComponent*, TArray<FItemNetInfo>*, bool, bool>(this, "AShooterPlayerController.ClientLoadArkItems_Implementation", forInventory, itemInfos, bClear, bFinalBatch); }
    void ClientFinishedLoadArkItems_Implementation(UPrimalInventoryComponent* forInventory) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ClientFinishedLoadArkItems_Implementation", forInventory); }
    void ClientInsertActorItem_Implementation(UPrimalInventoryComponent* forInventory, FItemNetInfo itemInfo, FItemNetID InsertAfterItemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetInfo, FItemNetID>(this, "AShooterPlayerController.ClientInsertActorItem_Implementation", forInventory, itemInfo, InsertAfterItemID); }
    void ClientRemoveActorItem_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID, bool showHUDMessage) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, bool>(this, "AShooterPlayerController.ClientRemoveActorItem_Implementation", forInventory, itemID, showHUDMessage); }
    void ClientSwapActorItems_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID1, FItemNetID itemID2) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, FItemNetID>(this, "AShooterPlayerController.ClientSwapActorItems_Implementation", forInventory, itemID1, itemID2); }
    void ClientUpdateInventoryCraftQueue_Implementation(UPrimalInventoryComponent* forInventory, TArray<FItemCraftQueueEntry>* CraftQueueEntries) { NativeCall<void, UPrimalInventoryComponent*, TArray<FItemCraftQueueEntry>*>(this, "AShooterPlayerController.ClientUpdateInventoryCraftQueue_Implementation", forInventory, CraftQueueEntries); }
    void ServerRequestActorItems_Implementation(UPrimalInventoryComponent* forInventory, bool bInventoryItems, bool bIsFirstSpawn) { NativeCall<void, UPrimalInventoryComponent*, bool, bool>(this, "AShooterPlayerController.ServerRequestActorItems_Implementation", forInventory, bInventoryItems, bIsFirstSpawn); }
    UPrimalInventoryComponent* GetPlayerInventory() { return NativeCall<UPrimalInventoryComponent*>(this, "AShooterPlayerController.GetPlayerInventory"); }
    void ServerRemovePawnItem_Implementation(FItemNetID itemID, bool bSecondryAction) { NativeCall<void, FItemNetID, bool>(this, "AShooterPlayerController.ServerRemovePawnItem_Implementation", itemID, bSecondryAction); }
    void ServerEquipPawnItem_Implementation(FItemNetID itemID) { NativeCall<void, FItemNetID>(this, "AShooterPlayerController.ServerEquipPawnItem_Implementation", itemID); }
    void ServerDeleteCustomFolder_Implementation(UPrimalInventoryComponent* forInventory, FString* CFolderName, int InventoryCompType) { NativeCall<void, UPrimalInventoryComponent*, FString*, int>(this, "AShooterPlayerController.ServerDeleteCustomFolder_Implementation", forInventory, CFolderName, InventoryCompType); }
    void ServerAddItemToCustomFolder_Implementation(UPrimalInventoryComponent* forInventory, FString* CFolderName, int InventoryCompType, FItemNetID ItemId) { NativeCall<void, UPrimalInventoryComponent*, FString*, int, FItemNetID>(this, "AShooterPlayerController.ServerAddItemToCustomFolder_Implementation", forInventory, CFolderName, InventoryCompType, ItemId); }
    void ServerDeleteItemFromCustomFolder_Implementation(UPrimalInventoryComponent* forInventory, FString* CFolderName, int InventoryCompType, FItemNetID ItemId) { NativeCall<void, UPrimalInventoryComponent*, FString*, int, FItemNetID>(this, "AShooterPlayerController.ServerDeleteItemFromCustomFolder_Implementation", forInventory, CFolderName, InventoryCompType, ItemId); }
    void ServerCraftItem_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerCraftItem_Implementation", inventoryComp, itemID); }
    void ServerRepairItem_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRepairItem_Implementation", inventoryComp, itemID); }
    void ServerRequestInventorySwapItems_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID1, FItemNetID itemID2) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, FItemNetID>(this, "AShooterPlayerController.ServerRequestInventorySwapItems_Implementation", inventoryComp, itemID1, itemID2); }
    void ServerRequestInventoryUseItemWithItem_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID1, FItemNetID itemID2, int AdditionalData) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, FItemNetID, int>(this, "AShooterPlayerController.ServerRequestInventoryUseItemWithItem_Implementation", inventoryComp, itemID1, itemID2, AdditionalData); }
    void ServerRequestInventoryUseItemWithActor_Implementation(AActor* anActor, UPrimalInventoryComponent* inventoryComp, FItemNetID itemID1, int AdditionalData) { NativeCall<void, AActor*, UPrimalInventoryComponent*, FItemNetID, int>(this, "AShooterPlayerController.ServerRequestInventoryUseItemWithActor_Implementation", anActor, inventoryComp, itemID1, AdditionalData); }
    void ServerRequestInventoryUseItem_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestInventoryUseItem_Implementation", inventoryComp, itemID); }
    void ServerActorViewRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerActorViewRemoteInventory_Implementation", inventoryComp); }
    void ServerActorCloseRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerActorCloseRemoteInventory_Implementation", inventoryComp); }
    void ServerDropFromRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerDropFromRemoteInventory_Implementation", inventoryComp, itemID); }
    void ServerInventoryClearCraftQueue_Implementation(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerInventoryClearCraftQueue_Implementation", inventoryComp); }
    void ServerRequestRemoveItemSkin_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestRemoveItemSkin_Implementation", inventoryComp, itemID); }
    void ServerRequestRemoveItemSkinOnly_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestRemoveItemSkinOnly_Implementation", inventoryComp, itemID); }
    void ServerRequestRemoveWeaponAccessoryOnly_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestRemoveWeaponAccessoryOnly_Implementation", inventoryComp, itemID); }
    void ServerRequestRemoveWeaponClipAmmo_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestRemoveWeaponClipAmmo_Implementation", inventoryComp, itemID); }
    void ServerEquipToRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerEquipToRemoteInventory_Implementation", 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", inventoryComp, itemID, requestedQuantity, ToSlotIndex, bEquipItem); }
    void ServerTransferAllFromRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp, FString* CurrentCustomFolderFilter, FString* CurrentNameFilter, FString* CurrentDestinationFolder, bool bNoFolderView) { NativeCall<void, UPrimalInventoryComponent*, FString*, FString*, FString*, bool>(this, "AShooterPlayerController.ServerTransferAllFromRemoteInventory_Implementation", inventoryComp, CurrentCustomFolderFilter, CurrentNameFilter, CurrentDestinationFolder, bNoFolderView); }
    bool CheckIsOnTransferAllCooldown(UPrimalInventoryComponent* inventoryComp) { return NativeCall<bool, UPrimalInventoryComponent*>(this, "AShooterPlayerController.CheckIsOnTransferAllCooldown", inventoryComp); }
    void ServerTransferAllToRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp, FString* CurrentCustomFolderFilter, FString* CurrentNameFilter, FString* CurrentDestinationFolder, bool bNoFolderView) { NativeCall<void, UPrimalInventoryComponent*, FString*, FString*, FString*, bool>(this, "AShooterPlayerController.ServerTransferAllToRemoteInventory_Implementation", inventoryComp, CurrentCustomFolderFilter, CurrentNameFilter, CurrentDestinationFolder, bNoFolderView); }
    void ServerTransferToRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, bool bAlsoTryToEqup, int requestedQuantity) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, bool, int>(this, "AShooterPlayerController.ServerTransferToRemoteInventory_Implementation", inventoryComp, itemID, bAlsoTryToEqup, requestedQuantity); }
    void ServerGrindItemInRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, bool grindStack) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, bool>(this, "AShooterPlayerController.ServerGrindItemInRemoteInventory_Implementation", 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", inventoryComp, itemID, requestedQuantity); }
    void OnRefreshSteamInventoryFinished(bool bSuccess, unsigned __int64 SteamID) { NativeCall<void, bool, unsigned __int64>(this, "AShooterPlayerController.OnRefreshSteamInventoryFinished", bSuccess, SteamID); }
    void ServerTakeItemFromArkInventoryAfterRefresh() { NativeCall<void>(this, "AShooterPlayerController.ServerTakeItemFromArkInventoryAfterRefresh"); }
    void ClientRemoveItemFromArk_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID RemovedItemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ClientRemoveItemFromArk_Implementation", forInventory, RemovedItemID); }
    void UploadCharaterDataToArk(UPrimalInventoryComponent* InvComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.UploadCharaterDataToArk", InvComp); }
    void ServerRequestCreateNewPlayerWithArkData(TArray<unsigned char>* PlayerArkDataBytes, unsigned __int64 TribeID) { NativeCall<void, TArray<unsigned char>*, unsigned __int64>(this, "AShooterPlayerController.ServerRequestCreateNewPlayerWithArkData", PlayerArkDataBytes, TribeID); }
    void ServerSetItemBalloonLocation_Implementation(APrimalStructureMovingContainer* ItemBalloon, FPrimalMapMarkerEntryData MapMarker) { NativeCall<void, APrimalStructureMovingContainer*, FPrimalMapMarkerEntryData>(this, "AShooterPlayerController.ServerSetItemBalloonLocation_Implementation", ItemBalloon, MapMarker); }
    void AddDinoToMap(APrimalDinoCharacter* Dino) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterPlayerController.AddDinoToMap", Dino); }
    void RemoveDinoFromMap(APrimalDinoCharacter* Dino) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterPlayerController.RemoveDinoFromMap", Dino); }
    void ServerUploadCurrentCharacterAndItems_Implementation(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerUploadCurrentCharacterAndItems_Implementation", inventoryComp); }
    void ClientOnCurrentCharacterAndItemsUploaded_Implementation(unsigned __int64 TransferringPlayerDataId) { NativeCall<void, unsigned __int64>(this, "AShooterPlayerController.ClientOnCurrentCharacterAndItemsUploaded_Implementation", TransferringPlayerDataId); }
    void OnCurrentCharacterAndItemsUploaded(bool Success) { NativeCall<void, bool>(this, "AShooterPlayerController.OnCurrentCharacterAndItemsUploaded", Success); }
    void ServerUploadCharaterDataToArk_Implementation(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerUploadCharaterDataToArk_Implementation", inventoryComp); }
    void UploadCharacterPlayerDataToArk(TArray<unsigned char>* PlayerDataBytes, FString PlayerName, TArray<FString> PlayerStats, unsigned __int64 PlayerDataId, bool WithItems, unsigned int ItemCount) { NativeCall<void, TArray<unsigned char>*, FString, TArray<FString>, unsigned __int64, bool, unsigned int>(this, "AShooterPlayerController.UploadCharacterPlayerDataToArk", PlayerDataBytes, PlayerName, PlayerStats, PlayerDataId, WithItems, ItemCount); }
    void RemoveInvetoryItem(unsigned int ItemID) { NativeCall<void, unsigned int>(this, "AShooterPlayerController.RemoveInvetoryItem", ItemID); }
    FVector* GetViewLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AShooterPlayerController.GetViewLocation", result); }
    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", InPawn); }
    void SetCharacterVivoxUsername(FString* InVivoxUsername) { NativeCall<void, FString*>(this, "AShooterPlayerController.SetCharacterVivoxUsername", InVivoxUsername); }
    void MulticastCharacterVivoxUsername() { NativeCall<void>(this, "AShooterPlayerController.MulticastCharacterVivoxUsername"); }
    void ServerRepeatMultiUse_Implementation(UObject* ForObject, int useIndex) { NativeCall<void, UObject*, int>(this, "AShooterPlayerController.ServerRepeatMultiUse_Implementation", ForObject, useIndex); }
    void ServerMultiUse_Implementation(UObject* ForObject, int useIndex) { NativeCall<void, UObject*, int>(this, "AShooterPlayerController.ServerMultiUse_Implementation", ForObject, useIndex); }
    void ClientDoMultiUse_Implementation(UObject* ForObject, int useIndex) { NativeCall<void, UObject*, int>(this, "AShooterPlayerController.ClientDoMultiUse_Implementation", ForObject, useIndex); }
    void ClientUpdateItemQuantity_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID, int ItemQuantity) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, int>(this, "AShooterPlayerController.ClientUpdateItemQuantity_Implementation", forInventory, itemID, ItemQuantity); }
    void ClientUpdateItemDurability_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID, float ItemDurability) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, float>(this, "AShooterPlayerController.ClientUpdateItemDurability_Implementation", forInventory, itemID, ItemDurability); }
    void ClientUpdateItemWeaponClipAmmo_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID, int Ammo) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, int>(this, "AShooterPlayerController.ClientUpdateItemWeaponClipAmmo_Implementation", forInventory, itemID, Ammo); }
    void ClientUsedActorItem_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ClientUsedActorItem_Implementation", forInventory, itemID); }
    void UnPossess() { NativeCall<void>(this, "AShooterPlayerController.UnPossess"); }
    void Possess(APawn* inPawn) { NativeCall<void, APawn*>(this, "AShooterPlayerController.Possess", 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", DeltaTime); }
    bool IsInputPressed(FName InputName, FName GamepadInputName) { return NativeCall<bool, FName, FName>(this, "AShooterPlayerController.IsInputPressed", InputName, GamepadInputName); }
    bool IsJumpInputPressed() { return NativeCall<bool>(this, "AShooterPlayerController.IsJumpInputPressed"); }
    bool IsAltFireInputPressed() { return NativeCall<bool>(this, "AShooterPlayerController.IsAltFireInputPressed"); }
    bool CanDoPlayerCharacterInput(bool bIgnoreCurrentWeapon, bool bWeaponForcesMountedWeaponry) { return NativeCall<bool, bool, bool>(this, "AShooterPlayerController.CanDoPlayerCharacterInput", bIgnoreCurrentWeapon, bWeaponForcesMountedWeaponry); }
    AActor* GetPlayerControllerViewerOverride() { return NativeCall<AActor*>(this, "AShooterPlayerController.GetPlayerControllerViewerOverride"); }
    void ForceTame(bool bCheatTame, APrimalDinoCharacter* Dino) { NativeCall<void, bool, APrimalDinoCharacter*>(this, "AShooterPlayerController.ForceTame", bCheatTame, Dino); }
    void SetImprintQuality(float ImprintingQuality) { NativeCall<void, float>(this, "AShooterPlayerController.SetImprintQuality", ImprintingQuality); }
    APrimalDinoCharacter* SetTamingEffectivenessModifier(float TamingEffectiveness) { return NativeCall<APrimalDinoCharacter*, float>(this, "AShooterPlayerController.SetTamingEffectivenessModifier", TamingEffectiveness); }
    void GiveToMe() { NativeCall<void>(this, "AShooterPlayerController.GiveToMe"); }
    void GiveActorToMe(AActor* anAct, bool bNotifyNetwork) { NativeCall<void, AActor*, bool>(this, "AShooterPlayerController.GiveActorToMe", anAct, bNotifyNetwork); }
    void ServerRequestLevelUp_Implementation(UPrimalCharacterStatusComponent* forStatusComp, EPrimalCharacterStatusValue::Type ValueType) { NativeCall<void, UPrimalCharacterStatusComponent*, EPrimalCharacterStatusValue::Type>(this, "AShooterPlayerController.ServerRequestLevelUp_Implementation", forStatusComp, ValueType); }
    void AddExperience(float HowMuch, bool fromTribeShare, bool bPreventSharingWithTribe) { NativeCall<void, float, bool, bool>(this, "AShooterPlayerController.AddExperience", HowMuch, fromTribeShare, bPreventSharingWithTribe); }
    void ServerRequestSetPin_Implementation(UObject* forTarget, int PinValue, bool bIsSetting, int TheCustomIndex) { NativeCall<void, UObject*, int, bool, int>(this, "AShooterPlayerController.ServerRequestSetPin_Implementation", forTarget, PinValue, bIsSetting, TheCustomIndex); }
    void ClientNotifyTribeXP_Implementation(float HowMuch) { NativeCall<void, float>(this, "AShooterPlayerController.ClientNotifyTribeXP_Implementation", HowMuch); }
    void ClientHUDNotificationTypeParams_Implementation(int MessageType, int MessageParam1, int MessageParam2, UObject* ObjectParam1) { NativeCall<void, int, int, int, UObject*>(this, "AShooterPlayerController.ClientHUDNotificationTypeParams_Implementation", MessageType, MessageParam1, MessageParam2, ObjectParam1); }
    AShooterPlayerState* GetShooterPlayerState() { return NativeCall<AShooterPlayerState*>(this, "AShooterPlayerController.GetShooterPlayerState"); }
    void ServerRequestRespawnAtPoint_Implementation(int spawnPointID, int spawnRegionIndex) { NativeCall<void, int, int>(this, "AShooterPlayerController.ServerRequestRespawnAtPoint_Implementation", spawnPointID, spawnRegionIndex); }
    void ServerRequestFastTravelToPoint_Implementation(int fromSpawnPointID, int spawnPointID) { NativeCall<void, int, int>(this, "AShooterPlayerController.ServerRequestFastTravelToPoint_Implementation", fromSpawnPointID, spawnPointID); }
    bool ServerDownloadDino(FARKTributeDino DownloadedDino) { return NativeCall<bool, FARKTributeDino>(this, "AShooterPlayerController.ServerDownloadDino", DownloadedDino); }
    void SendDinoToServer(FARKTributeDino DownloadedDino) { NativeCall<void, FARKTributeDino>(this, "AShooterPlayerController.SendDinoToServer", DownloadedDino); }
    void ServerUploadDino_Implementation(APrimalDinoCharacter* DownloadedDino) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterPlayerController.ServerUploadDino_Implementation", DownloadedDino); }
    void ServerRequestRemoteDropAllItems_Implementation(UPrimalInventoryComponent* inventoryComp, FString* CurrentCustomFolderFilter, FString* CurrentNameFilter) { NativeCall<void, UPrimalInventoryComponent*, FString*, FString*>(this, "AShooterPlayerController.ServerRequestRemoteDropAllItems_Implementation", inventoryComp, CurrentCustomFolderFilter, CurrentNameFilter); }
    void ServerRequestDropAllItems_Implementation(FString* CurrentCustomFolderFilter, FString* CurrentNameFilter) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ServerRequestDropAllItems_Implementation", CurrentCustomFolderFilter, CurrentNameFilter); }
    void ClientShowSpawnUI_Implementation(float Delay) { NativeCall<void, float>(this, "AShooterPlayerController.ClientShowSpawnUI_Implementation", Delay); }
    void ClientShowCharacterCreationUI_Implementation(bool bShowDownloadCharacter) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientShowCharacterCreationUI_Implementation", bShowDownloadCharacter); }
    AActor* SpawnActor(FString* blueprintPath, float spawnDistance, float spawnYOffset, float ZOffset, bool bDoDeferBeginPlay) { return NativeCall<AActor*, FString*, float, float, float, bool>(this, "AShooterPlayerController.SpawnActor", blueprintPath, spawnDistance, spawnYOffset, ZOffset, bDoDeferBeginPlay); }
    bool GiveItem(TArray<UPrimalItem*>* outItems, FString* blueprintPath, int quantityOverride, float qualityOverride, bool bForceBlueprint, bool bAutoEquip, float MinRandomQuality) { return NativeCall<bool, TArray<UPrimalItem*>*, FString*, int, float, bool, bool, float>(this, "AShooterPlayerController.GiveItem", outItems, blueprintPath, quantityOverride, qualityOverride, bForceBlueprint, bAutoEquip, MinRandomQuality); }
    bool GiveFast(FName* blueprintPath, int quantityOverride, float qualityOverride, bool bForceBlueprint, float MinRandomQuality) { return NativeCall<bool, FName*, int, float, bool, float>(this, "AShooterPlayerController.GiveFast", blueprintPath, quantityOverride, qualityOverride, bForceBlueprint, MinRandomQuality); }
    bool GiveSlotItem(FString* blueprintPath, int slotNum, int quantityOverride) { return NativeCall<bool, FString*, int, int>(this, "AShooterPlayerController.GiveSlotItem", blueprintPath, slotNum, quantityOverride); }
    bool GiveSlotItemNum(int masterIndexNum, int slotNum, int quantityOverride) { return NativeCall<bool, int, int, int>(this, "AShooterPlayerController.GiveSlotItemNum", masterIndexNum, slotNum, quantityOverride); }
    bool GiveItemNum(int masterIndexNum, int quantityOverride, float qualityOverride, bool bForceBlueprint) { return NativeCall<bool, int, int, float, bool>(this, "AShooterPlayerController.GiveItemNum", 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, FString* UserId, TArray<int>* MasterIndexNum) { NativeCall<void, bool, FString*, TArray<int>*>(this, "AShooterPlayerController.ClientOnAddedItemsToAllClustersInventory_Implementation", Success, UserId, MasterIndexNum); }
    void OnAddedItemsToAllClustersInventory(bool Success, FString* UserId, TArray<int>* MasterIndexNum) { NativeCall<void, bool, FString*, TArray<int>*>(this, "AShooterPlayerController.OnAddedItemsToAllClustersInventory", Success, UserId, MasterIndexNum); }
    bool AddItemToAllClustersInventory(FString UserId, int MasterIndexNum) { return NativeCall<bool, FString, int>(this, "AShooterPlayerController.AddItemToAllClustersInventory", 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", inPawn); }
    void BeginSpectatingState() { NativeCall<void>(this, "AShooterPlayerController.BeginSpectatingState"); }
    void SetGraphicsQuality(int val) { NativeCall<void, int>(this, "AShooterPlayerController.SetGraphicsQuality", val); }
    UShooterGameUserSettings* GetUserSettings() { return NativeCall<UShooterGameUserSettings*>(this, "AShooterPlayerController.GetUserSettings"); }
    void ResetSpawnTime() { NativeCall<void>(this, "AShooterPlayerController.ResetSpawnTime"); }
    void GetPlayerViewPoint(FVector* out_Location, FRotator* out_Rotation) { NativeCall<void, FVector*, FRotator*>(this, "AShooterPlayerController.GetPlayerViewPoint", out_Location, out_Rotation); }
    void GetPlayerViewPoint(FVector* out_Location, FRotator* out_Rotation, bool ForAiming) { NativeCall<void, FVector*, FRotator*, bool>(this, "AShooterPlayerController.GetPlayerViewPoint", out_Location, out_Rotation, ForAiming); }
    void GetPlayerViewPointNoModifiers(FVector* out_Location, FRotator* out_Rotation, bool ForAiming, bool bNoTPVAim) { NativeCall<void, FVector*, FRotator*, bool, bool>(this, "AShooterPlayerController.GetPlayerViewPointNoModifiers", out_Location, out_Rotation, ForAiming, bNoTPVAim); }
    void ClientNotifyEditText_Implementation(TSubclassOf<UObject> ForObjectClass, unsigned int ExtraID1, unsigned int ExtraID2, UObject* ForObject) { NativeCall<void, TSubclassOf<UObject>, unsigned int, unsigned int, UObject*>(this, "AShooterPlayerController.ClientNotifyEditText_Implementation", ForObjectClass, ExtraID1, ExtraID2, ForObject); }
    void ServerNotifyEditText_Implementation(FString* TextToUse, bool checkedBox, TSubclassOf<UObject> ForObjectClass, unsigned int ExtraID1, unsigned int ExtraID2, UObject* ForObject) { NativeCall<void, FString*, bool, TSubclassOf<UObject>, unsigned int, unsigned int, UObject*>(this, "AShooterPlayerController.ServerNotifyEditText_Implementation", TextToUse, checkedBox, ForObjectClass, ExtraID1, ExtraID2, ForObject); }
    void ServerSendChatMessage_Implementation(FString* ChatMessage, EChatSendMode::Type SendMode) { NativeCall<void, FString*, EChatSendMode::Type>(this, "AShooterPlayerController.ServerSendChatMessage_Implementation", ChatMessage, SendMode); }
    void LogChatMessage(FChatMessage* Msg) { NativeCall<void, FChatMessage*>(this, "AShooterPlayerController.LogChatMessage", Msg); }
    void ClientChatMessage_Implementation(FChatMessage Chat) { NativeCall<void, FChatMessage>(this, "AShooterPlayerController.ClientChatMessage_Implementation", Chat); }
    void ClientServerChatMessage_Implementation(FString* MessageText, FLinearColor MessageColor, bool bIsBold) { NativeCall<void, FString*, FLinearColor, bool>(this, "AShooterPlayerController.ClientServerChatMessage_Implementation", MessageText, MessageColor, bIsBold); }
    void ClientServerChatDirectMessage_Implementation(FString* MessageText, FLinearColor MessageColor, bool bIsBold) { NativeCall<void, FString*, FLinearColor, bool>(this, "AShooterPlayerController.ClientServerChatDirectMessage_Implementation", MessageText, MessageColor, bIsBold); }
    void ClientServerNotification_Implementation(FString* MessageText, FLinearColor MessageColor, float DisplayScale, float DisplayTime, UTexture2D* MessageIcon, USoundBase* SoundToPlay) { NativeCall<void, FString*, FLinearColor, float, float, UTexture2D*, USoundBase*>(this, "AShooterPlayerController.ClientServerNotification_Implementation", MessageText, MessageColor, DisplayScale, DisplayTime, MessageIcon, SoundToPlay); }
    void ClientServerNotificationSingle_Implementation(FString* MessageText, FLinearColor MessageColor, float DisplayScale, float DisplayTime, UTexture2D* MessageIcon, USoundBase* SoundToPlay, int MessageTypeID) { NativeCall<void, FString*, FLinearColor, float, float, UTexture2D*, USoundBase*, int>(this, "AShooterPlayerController.ClientServerNotificationSingle_Implementation", MessageText, MessageColor, DisplayScale, DisplayTime, MessageIcon, SoundToPlay, MessageTypeID); }
    void ClientServerSOTFNotification_Implementation(ESTOFNotificationType::Type NotificationType, FString* MessageText, FLinearColor MessageColor, float DisplayScale, float DisplayTime, UTexture2D* MessageIcon, USoundBase* SoundToPlay, bool bLastPlayer, FString* TribeName, TArray<FString>* PlayerNames, FString* DeathReason, TArray<FPrimalPlayerCharacterConfigStructReplicated>* DeadPlayersData) { NativeCall<void, ESTOFNotificationType::Type, FString*, FLinearColor, float, float, UTexture2D*, USoundBase*, bool, FString*, TArray<FString>*, FString*, TArray<FPrimalPlayerCharacterConfigStructReplicated>*>(this, "AShooterPlayerController.ClientServerSOTFNotification_Implementation", NotificationType, MessageText, MessageColor, DisplayScale, DisplayTime, MessageIcon, SoundToPlay, bLastPlayer, TribeName, PlayerNames, DeathReason, DeadPlayersData); }
    void ClientServerSOTFNotificationCustom_Implementation(FString* MessageText, FLinearColor MessageColor, float DisplayScale, float DisplayTime, UTexture2D* MessageIcon, USoundBase* SoundToPlay) { NativeCall<void, FString*, FLinearColor, float, float, UTexture2D*, USoundBase*>(this, "AShooterPlayerController.ClientServerSOTFNotificationCustom_Implementation", 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", HairColor); }
    void OrganizeSOTFQueue(TEnumAsByte<enum ESTOFNotificationType::Type> NotificationType, TArray<FString> PlayerNames, FString DeathReason, FString TribeName, TArray<FPrimalPlayerCharacterConfigStructReplicated> DeadPlayersData, bool bLastPlayer, bool bForcePlay, float DisplayInterval, FString CustomString) { NativeCall<void, TEnumAsByte<enum ESTOFNotificationType::Type>, TArray<FString>, FString, FString, TArray<FPrimalPlayerCharacterConfigStructReplicated>, bool, bool, float, FString>(this, "AShooterPlayerController.OrganizeSOTFQueue", NotificationType, PlayerNames, DeathReason, TribeName, DeadPlayersData, bLastPlayer, bForcePlay, DisplayInterval, CustomString); }
    FString* WritePNTScreenshot(FString* result) { return NativeCall<FString*, FString*>(this, "AShooterPlayerController.WritePNTScreenshot", result); }
    void TestNotification() { NativeCall<void>(this, "AShooterPlayerController.TestNotification"); }
    void TestPhysxPerf(int RayCount, float DistanceOfRays) { NativeCall<void, int, float>(this, "AShooterPlayerController.TestPhysxPerf", RayCount, DistanceOfRays); }
    void SetDoFInterpTime(float InterpTime) { NativeCall<void, float>(this, "AShooterPlayerController.SetDoFInterpTime", InterpTime); }
    void ClientReset_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientReset_Implementation"); }
    void Reset() { NativeCall<void>(this, "AShooterPlayerController.Reset"); }
    void SetCheatPlayer(bool bEnable) { NativeCall<void, bool>(this, "AShooterPlayerController.SetCheatPlayer", bEnable); }
    void DebugCheckSeven(bool bEnable) { NativeCall<void, bool>(this, "AShooterPlayerController.DebugCheckSeven", bEnable); }
    void SetAutoPlayer(bool bEnable) { NativeCall<void, bool>(this, "AShooterPlayerController.SetAutoPlayer", bEnable); }
    void CopyCoordsToClipboard() { NativeCall<void>(this, "AShooterPlayerController.CopyCoordsToClipboard"); }
    void CCC() { NativeCall<void>(this, "AShooterPlayerController.CCC"); }
    void ServerGlobalCommand_Implementation(FString* Msg) { NativeCall<void, FString*>(this, "AShooterPlayerController.ServerGlobalCommand_Implementation", Msg); }
    void GlobalCommand(FString* Msg) { NativeCall<void, FString*>(this, "AShooterPlayerController.GlobalCommand", Msg); }
    void GetAllMatinees() { NativeCall<void>(this, "AShooterPlayerController.GetAllMatinees"); }
    void TestAlarmNotification(FString Title, FString Message) { NativeCall<void, FString, FString>(this, "AShooterPlayerController.TestAlarmNotification", Title, Message); }
    void SendAlarmNotification(FString SteamID, FString Title, FString Message) { NativeCall<void, FString, FString, FString>(this, "AShooterPlayerController.SendAlarmNotification", 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", Index); }
    void ExportDinoData(APrimalDinoCharacter* DinoToExport) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterPlayerController.ExportDinoData", DinoToExport); }
    void ApplyDepthOfFieldSetting(int Index, float CurrentTimer) { NativeCall<void, int, float>(this, "AShooterPlayerController.ApplyDepthOfFieldSetting", Index, CurrentTimer); }
    void ServerReleaseSeatingStructure_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerReleaseSeatingStructure_Implementation"); }
    void AdminCheat(FString* Msg) { NativeCall<void, FString*>(this, "AShooterPlayerController.AdminCheat", 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", InstigatingPawn); }
    void ClientNotifyPlayerDeathReason_Implementation(FString* ReasonString) { NativeCall<void, FString*>(this, "AShooterPlayerController.ClientNotifyPlayerDeathReason_Implementation", ReasonString); }
    void ServerShowMessageOfTheDay_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerShowMessageOfTheDay_Implementation"); }
    void ServerSetMessageOfTheDay_Implementation(FString* Message) { NativeCall<void, FString*>(this, "AShooterPlayerController.ServerSetMessageOfTheDay_Implementation", Message); }
    void ClientNotifyMessageOfTheDay_Implementation(FString* Message, float TimeToDisplay) { NativeCall<void, FString*, float>(this, "AShooterPlayerController.ClientNotifyMessageOfTheDay_Implementation", Message, TimeToDisplay); }
    void ClientNotifyRemotePlayerDeath_Implementation(FString* PlayerName, FString* AttackerName) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ClientNotifyRemotePlayerDeath_Implementation", PlayerName, AttackerName); }
    void ClientNotifyPlayerKill_Implementation(AActor* PlayerPawn, APawn* VictimPawn) { NativeCall<void, AActor*, APawn*>(this, "AShooterPlayerController.ClientNotifyPlayerKill_Implementation", PlayerPawn, VictimPawn); }
    void ClientNotifyDinoKill_Implementation(APrimalDinoCharacter* InstigatingPawn, APawn* VictimPawn) { NativeCall<void, APrimalDinoCharacter*, APawn*>(this, "AShooterPlayerController.ClientNotifyDinoKill_Implementation", InstigatingPawn, VictimPawn); }
    void ClientNotifyDinoDeath_Implementation(FString* DinoName, FString* AttackerName, bool bIsVehicle) { NativeCall<void, FString*, FString*, bool>(this, "AShooterPlayerController.ClientNotifyDinoDeath_Implementation", DinoName, AttackerName, bIsVehicle); }
    void ServerRequestDinoCharStats_Implementation(APrimalDinoCharacter* theDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterPlayerController.ServerRequestDinoCharStats_Implementation", theDinoChar); }
    void ClientReceiveDinoCharStats_Implementation(APrimalDinoCharacter* theDinoChar, TArray<float>* CurValues, TArray<float>* MaxValues) { NativeCall<void, APrimalDinoCharacter*, TArray<float>*, TArray<float>*>(this, "AShooterPlayerController.ClientReceiveDinoCharStats_Implementation", theDinoChar, CurValues, MaxValues); }
    void HandleRespawned_Implementation(APawn* NewPawn, bool IsFirstSpawn) { NativeCall<void, APawn*, bool>(this, "AShooterPlayerController.HandleRespawned_Implementation", NewPawn, IsFirstSpawn); }
    void DisableEnemyInvisible() { NativeCall<void>(this, "AShooterPlayerController.DisableEnemyInvisible"); }
    void ClientNotifyRespawned_Implementation(APawn* NewPawn, bool IsFirstSpawn) { NativeCall<void, APawn*, bool>(this, "AShooterPlayerController.ClientNotifyRespawned_Implementation", NewPawn, IsFirstSpawn); }
    void ClientNotifyReconnected_Implementation(APawn* NewPawn) { NativeCall<void, APawn*>(this, "AShooterPlayerController.ClientNotifyReconnected_Implementation", 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(FString* ClassName) { NativeCall<void, FString*>(this, "AShooterPlayerController.HibernationReport", ClassName); }
    void HiWarp(FString* ClassName, int Index) { NativeCall<void, FString*, int>(this, "AShooterPlayerController.HiWarp", 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 InitHUD(bool bForceReinitUI) { NativeCall<void, bool>(this, "AShooterPlayerController.InitHUD", 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", bSetVRPlayer); }
    void ClientNotifyTamedDino_Implementation(TSubclassOf<APrimalDinoCharacter> DinoClass) { NativeCall<void, TSubclassOf<APrimalDinoCharacter>>(this, "AShooterPlayerController.ClientNotifyTamedDino_Implementation", DinoClass); }
    void ClientNotifySummonedDino_Implementation(TSubclassOf<APrimalDinoCharacter> DinoClass) { NativeCall<void, TSubclassOf<APrimalDinoCharacter>>(this, "AShooterPlayerController.ClientNotifySummonedDino_Implementation", DinoClass); }
    void ClientNotifyDefeatedDino_Implementation(TSubclassOf<APrimalDinoCharacter> DinoClass) { NativeCall<void, TSubclassOf<APrimalDinoCharacter>>(this, "AShooterPlayerController.ClientNotifyDefeatedDino_Implementation", DinoClass); }
    void SetPlayerPos(float X, float Y, float Z) { NativeCall<void, float, float, float>(this, "AShooterPlayerController.SetPlayerPos", 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", X, Y, Z, Yaw, Pitch); }
    void ClientSetSpectatorLocation_Implementation(FVector NewLocation) { NativeCall<void, FVector>(this, "AShooterPlayerController.ClientSetSpectatorLocation_Implementation", NewLocation); }
    void ClientSetControlRotation_Implementation(FRotator NewRotation) { NativeCall<void, FRotator>(this, "AShooterPlayerController.ClientSetControlRotation_Implementation", NewRotation); }
    bool ShouldReplicateVoicePacketFrom(FUniqueNetId* Sender, char ShouldUseSuperRange, char* PlaybackFlags) { return NativeCall<bool, FUniqueNetId*, char, char*>(this, "AShooterPlayerController.ShouldReplicateVoicePacketFrom", Sender, ShouldUseSuperRange, PlaybackFlags); }
    bool HasRadio() { return NativeCall<bool>(this, "AShooterPlayerController.HasRadio"); }
    TArray<unsigned int>* GetRadioFrequencies(TArray<unsigned int>* result) { return NativeCall<TArray<unsigned int>*, TArray<unsigned int>*>(this, "AShooterPlayerController.GetRadioFrequencies", result); }
    bool HasSameRadioFrequency(AShooterPlayerController* OtherPC, unsigned int* SharedFrequency) { return NativeCall<bool, AShooterPlayerController*, unsigned int*>(this, "AShooterPlayerController.HasSameRadioFrequency", OtherPC, SharedFrequency); }
    float GetChatProximityRadius() { return NativeCall<float>(this, "AShooterPlayerController.GetChatProximityRadius"); }
    void ToggleSpeaking(bool bSpeaking, bool UseSuperRange) { NativeCall<void, bool, bool>(this, "AShooterPlayerController.ToggleSpeaking", bSpeaking, UseSuperRange); }
    void ForceUnstasisAtLocation(FVector AtLocation) { NativeCall<void, FVector>(this, "AShooterPlayerController.ForceUnstasisAtLocation", AtLocation); }
    void SpawnActorSpread(FString* blueprintPath, float spawnDistance, float spawnYOffset, float ZOffset, int NumberActors, float SpreadAmount) { NativeCall<void, FString*, float, float, float, int, float>(this, "AShooterPlayerController.SpawnActorSpread", blueprintPath, spawnDistance, spawnYOffset, ZOffset, NumberActors, SpreadAmount); }
    void SpawnActorSpreadTamed(FString* blueprintPath, float spawnDistance, float spawnYOffset, float ZOffset, int NumberActors, float SpreadAmount) { NativeCall<void, FString*, float, float, float, int, float>(this, "AShooterPlayerController.SpawnActorSpreadTamed", 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", bForceAllEngrams, bTekEngramsOnly); }
    void ForceTribes(FString* PlayerName1, FString* PlayerName2, FString* NewTribeName) { NativeCall<void, FString*, FString*, FString*>(this, "AShooterPlayerController.ForceTribes", PlayerName1, PlayerName2, NewTribeName); }
    void ClientPlayLocalSound_Implementation(USoundBase* aSound, bool bAttach) { NativeCall<void, USoundBase*, bool>(this, "AShooterPlayerController.ClientPlayLocalSound_Implementation", aSound, bAttach); }
    void ClientStopLocalSound_Implementation(USoundBase* aSound) { NativeCall<void, USoundBase*>(this, "AShooterPlayerController.ClientStopLocalSound_Implementation", aSound); }
    void ServerAddItemToArkInventory_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, int requestedQuantity) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, int>(this, "AShooterPlayerController.ServerAddItemToArkInventory_Implementation", inventoryComp, itemID, requestedQuantity); }
    void OnArkTributeAllClustersInventoryItemsLoaded(TArray<FItemNetInfo>* Items, bool bAllowForcedItemDownload) { NativeCall<void, TArray<FItemNetInfo>*, bool>(this, "AShooterPlayerController.OnArkTributeAllClustersInventoryItemsLoaded", Items, bAllowForcedItemDownload); }
    void OnArkTributeSaved(bool Success) { NativeCall<void, bool>(this, "AShooterPlayerController.OnArkTributeSaved", 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", LimitItems, LimitDinos, LimitCharacters, MaxItems, MaxDinos, MaxCharacters); }
    void ServerLoadArkInventoryItems_Implementation(TArray<FItemNetInfo>* ArkInventoryItemsInfo, bool bFinalBatch) { NativeCall<void, TArray<FItemNetInfo>*, bool>(this, "AShooterPlayerController.ServerLoadArkInventoryItems_Implementation", ArkInventoryItemsInfo, bFinalBatch); }
    void ServerAsyncLoadArkInventoryItems_Implementation(TArray<FItemNetInfo>* ArkInventoryItemsInfo, bool bFinalBatch) { NativeCall<void, TArray<FItemNetInfo>*, bool>(this, "AShooterPlayerController.ServerAsyncLoadArkInventoryItems_Implementation", ArkInventoryItemsInfo, bFinalBatch); }
    void GetTamedDinosNearBy(TArray<TWeakObjectPtr<APrimalDinoCharacter>>* Dinos) { NativeCall<void, TArray<TWeakObjectPtr<APrimalDinoCharacter>>*>(this, "AShooterPlayerController.GetTamedDinosNearBy", Dinos); }
    void GetTamedDinosNearBy(TArray<TWeakObjectPtr<APrimalDinoCharacter>>* Dinos, float RangeRadius) { NativeCall<void, TArray<TWeakObjectPtr<APrimalDinoCharacter>>*, float>(this, "AShooterPlayerController.GetTamedDinosNearBy", Dinos, RangeRadius); }
    bool IsTamedDinoNearBy(APrimalDinoCharacter* Dino, float RangeRadius) { return NativeCall<bool, APrimalDinoCharacter*, float>(this, "AShooterPlayerController.IsTamedDinoNearBy", Dino, RangeRadius); }
    void TestSteamRefreshItems() { NativeCall<void>(this, "AShooterPlayerController.TestSteamRefreshItems"); }
    void ServerSendArkDataPayloadBegin_Implementation(FGuid ID, EPrimalARKTributeDataType::Type ArkDataType, FString* DataClass, FString* TagName, FString* Name, TArray<FString>* DataStats, unsigned int ID1, unsigned int ID2) { NativeCall<void, FGuid, EPrimalARKTributeDataType::Type, FString*, FString*, FString*, TArray<FString>*, unsigned int, unsigned int>(this, "AShooterPlayerController.ServerSendArkDataPayloadBegin_Implementation", ID, ArkDataType, DataClass, TagName, Name, DataStats, ID1, ID2); }
    void ServerSendArkDataPayload_Implementation(FGuid ID, EPrimalARKTributeDataType::Type ArkDataType, TArray<unsigned char>* DataBytes) { NativeCall<void, FGuid, EPrimalARKTributeDataType::Type, TArray<unsigned char>*>(this, "AShooterPlayerController.ServerSendArkDataPayload_Implementation", ID, ArkDataType, DataBytes); }
    void ServerSendArkDataPayloadEnd_Implementation(FGuid ID, EPrimalARKTributeDataType::Type ArkDataType) { NativeCall<void, FGuid, EPrimalARKTributeDataType::Type>(this, "AShooterPlayerController.ServerSendArkDataPayloadEnd_Implementation", ID, ArkDataType); }
    void ClientSendArkDataPayloadBegin_Implementation(FGuid ID, EPrimalARKTributeDataType::Type ArkDataType, FString* DataClass, FString* TagName, FString* Name, TArray<FString>* DataStats, unsigned int ID1, unsigned int ID2) { NativeCall<void, FGuid, EPrimalARKTributeDataType::Type, FString*, FString*, FString*, TArray<FString>*, unsigned int, unsigned int>(this, "AShooterPlayerController.ClientSendArkDataPayloadBegin_Implementation", 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", ID, ArkDataType, PlayerDataID); }
    void RequestCreateNewPlayerWithArkDataPossibleItems(FArkTributePlayerData* PlayerData, unsigned __int64 TribeID) { NativeCall<void, FArkTributePlayerData*, unsigned __int64>(this, "AShooterPlayerController.RequestCreateNewPlayerWithArkDataPossibleItems", PlayerData, TribeID); }
    void ServerCharacterUploadWithItems_Start_Implementation(unsigned __int64 PlayerDataId, FArkTributePlayerData PlayerData) { NativeCall<void, unsigned __int64, FArkTributePlayerData>(this, "AShooterPlayerController.ServerCharacterUploadWithItems_Start_Implementation", PlayerDataId, PlayerData); }
    void ServerCharacterUploadWithItems_CharaterPayload_Implementation(unsigned __int64 PlayerDataId, TArray<unsigned char>* PlayerDataChunk) { NativeCall<void, unsigned __int64, TArray<unsigned char>*>(this, "AShooterPlayerController.ServerCharacterUploadWithItems_CharaterPayload_Implementation", PlayerDataId, PlayerDataChunk); }
    void ServerCharacterUploadWithItems_UploadItem_Implementation(unsigned __int64 PlayerDataId, FItemNetInfo InvItem) { NativeCall<void, unsigned __int64, FItemNetInfo>(this, "AShooterPlayerController.ServerCharacterUploadWithItems_UploadItem_Implementation", PlayerDataId, InvItem); }
    void ServerCharacterUploadWithItems_FinishAndCreateCharacter_Implementation(unsigned __int64 PlayerDataId) { NativeCall<void, unsigned __int64>(this, "AShooterPlayerController.ServerCharacterUploadWithItems_FinishAndCreateCharacter_Implementation", 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", result, MissionTag); }
    bool HasBestScoreForMission(FName MissionTag) { return NativeCall<bool, FName>(this, "AShooterPlayerController.HasBestScoreForMission", MissionTag); }
    FLeaderboardRow* GetBestScoreForMission(FLeaderboardRow* result, FName MissionTag) { return NativeCall<FLeaderboardRow*, FLeaderboardRow*, FName>(this, "AShooterPlayerController.GetBestScoreForMission", result, MissionTag); }
    void ServerRequestShowLeaderboards_Implementation(TSubclassOf<ULeaderboard> LeaderboardType, FName MissionTag) { NativeCall<void, TSubclassOf<ULeaderboard>, FName>(this, "AShooterPlayerController.ServerRequestShowLeaderboards_Implementation", LeaderboardType, MissionTag); }
    void ClientShowLeaderboard_Implementation(TSubclassOf<ULeaderboard> LeaderboardType, FName MissionTag, TArray<FLeaderboardRow>* LeaderboardRows, bool bPlayerHasValidLatestScore, FLeaderboardRow LatestPlayerScore) { NativeCall<void, TSubclassOf<ULeaderboard>, FName, TArray<FLeaderboardRow>*, bool, FLeaderboardRow>(this, "AShooterPlayerController.ClientShowLeaderboard_Implementation", LeaderboardType, MissionTag, LeaderboardRows, bPlayerHasValidLatestScore, LatestPlayerScore); }
    void RequestCreateNewPlayerWithArkData(TArray<unsigned char> PlayerArkDataBytes, unsigned __int64 TribeID) { NativeCall<void, TArray<unsigned char>, unsigned __int64>(this, "AShooterPlayerController.RequestCreateNewPlayerWithArkData", PlayerArkDataBytes, TribeID); }
    void SendArKPayload(bool bClient, FARKTributeData ArKDataPayload) { NativeCall<void, bool, FARKTributeData>(this, "AShooterPlayerController.SendArKPayload", 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(TArray<FARKTributeDinoListing>* UploadedDinosListings) { NativeCall<void, TArray<FARKTributeDinoListing>*>(this, "AShooterPlayerController.ClientUploadedDinosLoaded_Implementation", UploadedDinosListings); }
    void ServerRequestDownloadDino_Implementation(FARKTributeDino DownloadedDino) { NativeCall<void, FARKTributeDino>(this, "AShooterPlayerController.ServerRequestDownloadDino_Implementation", DownloadedDino); }
    void ClientDownloadDinoRequestFinished_Implementation(bool Success) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientDownloadDinoRequestFinished_Implementation", Success); }
    void OnLoadArkTributePlayersDataFinished(bool Success, TArray<FArkTributePlayerData>* ArkUploadedCharsData, int FailureResponseCode) { NativeCall<void, bool, TArray<FArkTributePlayerData>*, int>(this, "AShooterPlayerController.OnLoadArkTributePlayersDataFinished", 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, FString* FailureResponseMessage) { NativeCall<void, bool, int, FString*>(this, "AShooterPlayerController.ClientOnEndDownloadTransferredPlayerCharacter_Implementation", Success, FailureResponseCode, FailureResponseMessage); }
    void DownloadTransferredPlayerCharacter() { NativeCall<void>(this, "AShooterPlayerController.DownloadTransferredPlayerCharacter"); }
    void ClientUploadedCharactersLoaded_Implementation(bool Success, TArray<FArkTributePlayerDataListing>* UploadedDinosListings) { NativeCall<void, bool, TArray<FArkTributePlayerDataListing>*>(this, "AShooterPlayerController.ClientUploadedCharactersLoaded_Implementation", Success, UploadedDinosListings); }
    void ServerCheckIsValidPlayerToDownload_Implementation(FArkTributePlayerData PlayerData) { NativeCall<void, FArkTributePlayerData>(this, "AShooterPlayerController.ServerCheckIsValidPlayerToDownload_Implementation", PlayerData); }
    void ClientPlayerIsValidToDownload_Implementation(bool bIsValid, FArkTributePlayerData PlayerData) { NativeCall<void, bool, FArkTributePlayerData>(this, "AShooterPlayerController.ClientPlayerIsValidToDownload_Implementation", bIsValid, PlayerData); }
    bool IsValidArkTributePlayerDownloadForThisServer(FArkTributePlayerData* PlayerData) { return NativeCall<bool, FArkTributePlayerData*>(this, "AShooterPlayerController.IsValidArkTributePlayerDownloadForThisServer", PlayerData); }
    void ServerRequestDownloadPlayerCharacter_Implementation(FArkTributePlayerData DownloadedCharacter, int spawnPointID, int spawnRegionIndex) { NativeCall<void, FArkTributePlayerData, int, int>(this, "AShooterPlayerController.ServerRequestDownloadPlayerCharacter_Implementation", DownloadedCharacter, spawnPointID, spawnRegionIndex); }
    void ClientDownloadPlayerCharacterRequestFinished_Implementation(bool Success) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientDownloadPlayerCharacterRequestFinished_Implementation", Success); }
    FString* LinkedPlayerIDString(FString* result) { return NativeCall<FString*, FString*>(this, "AShooterPlayerController.LinkedPlayerIDString", result); }
    FString LinkedPlayerIDString() { FString result; return *LinkedPlayerIDString(&result); }
    void ServerSetSubscribedApp_Implementation(int AppID, bool bPreventDefaultItems) { NativeCall<void, int, bool>(this, "AShooterPlayerController.ServerSetSubscribedApp_Implementation", AppID, bPreventDefaultItems); }
    void ServerAddItemToSteamInventory(int ItemSteamDefID, int Quantity) { NativeCall<void, int, int>(this, "AShooterPlayerController.ServerAddItemToSteamInventory", ItemSteamDefID, Quantity); }
    void ClientRemoveItemFromSteamInventory_Implementation(TArray<unsigned __int64>* ItemSteamUserID, int Quantity) { NativeCall<void, TArray<unsigned __int64>*, int>(this, "AShooterPlayerController.ClientRemoveItemFromSteamInventory_Implementation", ItemSteamUserID, Quantity); }
    void ServerRemoveSteamItemSucceeded_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerRemoveSteamItemSucceeded_Implementation"); }
    void OnConsumeItemFinished(bool bSuccess, unsigned __int64 SteamID) { NativeCall<void, bool, unsigned __int64>(this, "AShooterPlayerController.OnConsumeItemFinished", bSuccess, SteamID); }
    void RemoveItemSucceeded() { NativeCall<void>(this, "AShooterPlayerController.RemoveItemSucceeded"); }
    void OnAddItemFinished(bool bSuccess, TArray<unsigned __int64> SteamItemUserIds, unsigned __int64 SteamID) { NativeCall<void, bool, TArray<unsigned __int64>, unsigned __int64>(this, "AShooterPlayerController.OnAddItemFinished", bSuccess, SteamItemUserIds, SteamID); }
    void ServerRefreshSteamInventoryForRemove() { NativeCall<void>(this, "AShooterPlayerController.ServerRefreshSteamInventoryForRemove"); }
    void ServerRefreshSteamInventoryToCheckConsume() { NativeCall<void>(this, "AShooterPlayerController.ServerRefreshSteamInventoryToCheckConsume"); }
    void ServerRefreshSteamInventory_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerRefreshSteamInventory_Implementation"); }
    void OnServerRefreshSteamInventoryFinished(bool bSuccess, unsigned __int64 SteamID) { NativeCall<void, bool, unsigned __int64>(this, "AShooterPlayerController.OnServerRefreshSteamInventoryFinished", bSuccess, SteamID); }
    void OnRefreshSteamInventoryToCheckConsumeFinished(bool bSuccess, unsigned __int64 SteamID) { NativeCall<void, bool, unsigned __int64>(this, "AShooterPlayerController.OnRefreshSteamInventoryToCheckConsumeFinished", bSuccess, SteamID); }
    void ClientRefreshSteamInventoryFinished_Implementation(bool bSuccess) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientRefreshSteamInventoryFinished_Implementation", bSuccess); }
    void RefreshSteamInventory() { NativeCall<void>(this, "AShooterPlayerController.RefreshSteamInventory"); }
    void ServerRemoveSteamItem_Implementation(unsigned int ItemdDefId) { NativeCall<void, unsigned int>(this, "AShooterPlayerController.ServerRemoveSteamItem_Implementation", ItemdDefId); }
    void ReceivedPlayerState() { NativeCall<void>(this, "AShooterPlayerController.ReceivedPlayerState"); }
    void CloseSteamStatusScene() { NativeCall<void>(this, "AShooterPlayerController.CloseSteamStatusScene"); }
    void AllowPlayerToJoinNoCheck(FString* PlayerId) { NativeCall<void, FString*>(this, "AShooterPlayerController.AllowPlayerToJoinNoCheck", PlayerId); }
    void ServerAllowPlayerToJoinNoCheck_Implementation(FString* PlayerId) { NativeCall<void, FString*>(this, "AShooterPlayerController.ServerAllowPlayerToJoinNoCheck_Implementation", PlayerId); }
    void DisallowPlayerToJoinNoCheck(FString* PlayerId) { NativeCall<void, FString*>(this, "AShooterPlayerController.DisallowPlayerToJoinNoCheck", PlayerId); }
    void ServerDisallowPlayerToJoinNoCheck_Implementation(FString* PlayerId) { NativeCall<void, FString*>(this, "AShooterPlayerController.ServerDisallowPlayerToJoinNoCheck_Implementation", PlayerId); }
    void ServerSendDirectMessage_Implementation(FString* PlayerSteamID, FString* MessageText) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ServerSendDirectMessage_Implementation", PlayerSteamID, MessageText); }
    void ServerListPlayers_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerListPlayers_Implementation"); }
    void KickPlayer(FString PlayerSteamName) { NativeCall<void, FString>(this, "AShooterPlayerController.KickPlayer", PlayerSteamName); }
    void ServerKickPlayer_Implementation(FString* PlayerSteamName, FString* PlayerSteamID) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ServerKickPlayer_Implementation", PlayerSteamName, PlayerSteamID); }
    void BanPlayer(FString PlayerSteamName) { NativeCall<void, FString>(this, "AShooterPlayerController.BanPlayer", PlayerSteamName); }
    void ServerBanPlayer_Implementation(FString* PlayerSteamName, FString* PlayerSteamID) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ServerBanPlayer_Implementation", PlayerSteamName, PlayerSteamID); }
    void UnbanPlayer(FString PlayerSteamName) { NativeCall<void, FString>(this, "AShooterPlayerController.UnbanPlayer", PlayerSteamName); }
    void ServerUnbanPlayer_Implementation(FString* PlayerSteamName, FString* PlayerSteamID) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ServerUnbanPlayer_Implementation", PlayerSteamName, PlayerSteamID); }
    void SetKickedNotification(FString KickReason) { NativeCall<void, FString>(this, "AShooterPlayerController.SetKickedNotification", KickReason); }
    void ClientUnlockAchievement_Implementation(FString* AchievementID) { NativeCall<void, FString*>(this, "AShooterPlayerController.ClientUnlockAchievement_Implementation", AchievementID); }
    void ClientNotifyLevelUp_Implementation(APrimalCharacter* ForChar, int NewLevel) { NativeCall<void, APrimalCharacter*, int>(this, "AShooterPlayerController.ClientNotifyLevelUp_Implementation", ForChar, NewLevel); }
    void ClientNotifyAdmin_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyAdmin_Implementation"); }
    void ClientNotifyTorpidityIncrease_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyTorpidityIncrease_Implementation"); }
    void ServerPaint_Implementation(UStructurePaintingComponent* Structure, TArray<FPaintItem>* Paints, bool bLastBatch, bool bFromLoadFile) { NativeCall<void, UStructurePaintingComponent*, TArray<FPaintItem>*, bool, bool>(this, "AShooterPlayerController.ServerPaint_Implementation", Structure, Paints, bLastBatch, bFromLoadFile); }
    void InitCharacterPainting_Implementation(APrimalCharacter* Char) { NativeCall<void, APrimalCharacter*>(this, "AShooterPlayerController.InitCharacterPainting_Implementation", 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", NewState); }
    bool IsSpectator() { return NativeCall<bool>(this, "AShooterPlayerController.IsSpectator"); }
    void ClientFailedRemoveSaddle_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientFailedRemoveSaddle_Implementation"); }
    void PrintColors() { NativeCall<void>(this, "AShooterPlayerController.PrintColors"); }
    FString* ConsoleCommand(FString* result, FString* Command, bool bWriteToLog) { return NativeCall<FString*, FString*, FString*, bool>(this, "AShooterPlayerController.ConsoleCommand", result, Command, bWriteToLog); }
    void ClientRunLocalConsoleCommand_Implementation(FString* Command, bool bWriteToLog) { NativeCall<void, FString*, bool>(this, "AShooterPlayerController.ClientRunLocalConsoleCommand_Implementation", Command, bWriteToLog); }
    void EnvQA() { NativeCall<void>(this, "AShooterPlayerController.EnvQA"); }
    void TurnOnGmBuffAndTekArmorAndStatFpsAndAlsoStatUnitBecauseThisIsEasierToTypeOnXbox() { NativeCall<void>(this, "AShooterPlayerController.TurnOnGmBuffAndTekArmorAndStatFpsAndAlsoStatUnitBecauseThisIsEasierToTypeOnXbox"); }
    void GiveColors(int quantity) { NativeCall<void, int>(this, "AShooterPlayerController.GiveColors", quantity); }
    void ClientShowPaintingUI_Implementation(UObject* ObjectToPaint) { NativeCall<void, UObject*>(this, "AShooterPlayerController.ClientShowPaintingUI_Implementation", ObjectToPaint); }
    void HideRiders(bool bDoHide) { NativeCall<void, bool>(this, "AShooterPlayerController.HideRiders", bDoHide); }
    void SetAdminIcon(bool bAdminIcon) { NativeCall<void, bool>(this, "AShooterPlayerController.SetAdminIcon", bAdminIcon); }
    void SpawnPlayerCameraManager() { NativeCall<void>(this, "AShooterPlayerController.SpawnPlayerCameraManager"); }
    void ServerSetSupressAdminIcon_Implementation(bool bSuppress) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerSetSupressAdminIcon_Implementation", bSuppress); }
    void NotifyTribeWarStatus_Implementation(FString* EnemyTribeString, int StatusType) { NativeCall<void, FString*, int>(this, "AShooterPlayerController.NotifyTribeWarStatus_Implementation", EnemyTribeString, StatusType); }
    void StartArkGamepadLeftShoulder() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadLeftShoulder"); }
    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(FString* LogString) { NativeCall<void, FString*>(this, "AShooterPlayerController.ClientReceiveTribeLog_Implementation", LogString); }
    void ClientEndReceivingTribeLog_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientEndReceivingTribeLog_Implementation"); }
    void EndArkGamepadLeftShoulder() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadLeftShoulder"); }
    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 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"); }
    bool IsGameInputAllowed() { return NativeCall<bool>(this, "AShooterPlayerController.IsGameInputAllowed"); }
    void ServerAddAchievementID_Implementation(FString* AchievementID, bool bIsOnSpawn) { NativeCall<void, FString*, bool>(this, "AShooterPlayerController.ServerAddAchievementID_Implementation", AchievementID, bIsOnSpawn); }
    int GetLinkedPlayerID() { return NativeCall<int>(this, "AShooterPlayerController.GetLinkedPlayerID"); }
    unsigned __int64 GetLinkedPlayerID64() { return NativeCall<unsigned __int64>(this, "AShooterPlayerController.GetLinkedPlayerID64"); }
    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", ItemClass); }
    bool AllowTribeGroupPermission(ETribeGroupPermission::Type TribeGroupPermission, UObject* OnObject) { return NativeCall<bool, ETribeGroupPermission::Type, UObject*>(this, "AShooterPlayerController.AllowTribeGroupPermission", 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", AtLocation, DamageAmount, FromTeamID); }
    void ClientAddFloatingText_Implementation(FVector_NetQuantize AtLocation, FString* FloatingTextString, FColor FloatingTextColor, float ScaleX, float ScaleY, float TextLifeSpan, FVector TextVelocity, float MinScale, float FadeInTime, float FadeOutTime) { NativeCall<void, FVector_NetQuantize, FString*, FColor, float, float, float, FVector, float, float, float>(this, "AShooterPlayerController.ClientAddFloatingText_Implementation", AtLocation, FloatingTextString, FloatingTextColor, ScaleX, ScaleY, TextLifeSpan, TextVelocity, MinScale, FadeInTime, FadeOutTime); }
    UPrimalItem* GetInventoryUISelectedItemLocal() { return NativeCall<UPrimalItem*>(this, "AShooterPlayerController.GetInventoryUISelectedItemLocal"); }
    UPrimalItem* GetInventoryUISelectedItemRemote() { return NativeCall<UPrimalItem*>(this, "AShooterPlayerController.GetInventoryUISelectedItemRemote"); }
    void NotifyDealDamageSuccess(APrimalCharacter* HitCharacter, bool bHitFriendlyTarget, float PreDamageHealth, float DamageAmount, FDamageEvent* DamageEvent) { NativeCall<void, APrimalCharacter*, bool, float, float, FDamageEvent*>(this, "AShooterPlayerController.NotifyDealDamageSuccess", HitCharacter, bHitFriendlyTarget, PreDamageHealth, DamageAmount, DamageEvent); }
    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", bAccept); }
    void ServerTransferredPlayerConfirmationResult_Implementation(bool bAccpet) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerTransferredPlayerConfirmationResult_Implementation", bAccpet); }
    void ClientSetHUDAndInitUIScenes_Implementation(TSubclassOf<AHUD> NewHUDClass) { NativeCall<void, TSubclassOf<AHUD>>(this, "AShooterPlayerController.ClientSetHUDAndInitUIScenes_Implementation", NewHUDClass); }
    void ClientShowSpawnUIForTransferringPlayer_Implementation(TSubclassOf<AHUD> NewHUDClass, unsigned __int64 TransferingPlayerID, bool bUseTimer) { NativeCall<void, TSubclassOf<AHUD>, unsigned __int64, bool>(this, "AShooterPlayerController.ClientShowSpawnUIForTransferringPlayer_Implementation", NewHUDClass, TransferingPlayerID, bUseTimer); }
    void ServerDownloadTransferredPlayer_Implementation(int spawnPointID, int spawnPointRegionIndex) { NativeCall<void, int, int>(this, "AShooterPlayerController.ServerDownloadTransferredPlayer_Implementation", spawnPointID, spawnPointRegionIndex); }
    void GetAudioListenerPosition(FVector* OutLocation, FVector* OutFrontDir, FVector* OutRightDir) { NativeCall<void, FVector*, FVector*, FVector*>(this, "AShooterPlayerController.GetAudioListenerPosition", OutLocation, OutFrontDir, OutRightDir); }
    void ServerStartWeaponFire_Implementation(AShooterWeapon* weapon) { NativeCall<void, AShooterWeapon*>(this, "AShooterPlayerController.ServerStartWeaponFire_Implementation", weapon); }
    void ServerStopWeaponFire_Implementation(AShooterWeapon* weapon) { NativeCall<void, AShooterWeapon*>(this, "AShooterPlayerController.ServerStopWeaponFire_Implementation", weapon); }
    void ServerStartWeaponAltFire_Implementation(AShooterWeapon* weapon) { NativeCall<void, AShooterWeapon*>(this, "AShooterPlayerController.ServerStartWeaponAltFire_Implementation", weapon); }
    void ServerStopWeaponAltFire_Implementation(AShooterWeapon* weapon) { NativeCall<void, AShooterWeapon*>(this, "AShooterPlayerController.ServerStopWeaponAltFire_Implementation", weapon); }
    void StartSurfaceCamera(float OnSurfaceTargetYaw, float OnSurfaceTargetPitch, float OnSurfaceTargetRoll, float OnSurfaceCameraInterpolationSpeed, bool UseSurfaceCameraInterpolation, FVector* CameraOffset) { NativeCall<void, float, float, float, float, bool, FVector*>(this, "AShooterPlayerController.StartSurfaceCamera", OnSurfaceTargetYaw, OnSurfaceTargetPitch, OnSurfaceTargetRoll, OnSurfaceCameraInterpolationSpeed, UseSurfaceCameraInterpolation, CameraOffset); }
    void StartSurfaceCameraForPassenger(float OnSurfaceTargetYaw, float OnSurfaceTargetPitch, float OnSurfaceTargetRoll) { NativeCall<void, float, float, float>(this, "AShooterPlayerController.StartSurfaceCameraForPassenger", OnSurfaceTargetYaw, OnSurfaceTargetPitch, OnSurfaceTargetRoll); }
    void EndSurfaceCamera() { NativeCall<void>(this, "AShooterPlayerController.EndSurfaceCamera"); }
    void DisableSurfaceCameraInterpolation() { NativeCall<void>(this, "AShooterPlayerController.DisableSurfaceCameraInterpolation"); }
    void ClientStartSurfaceCameraForPassenger_Implementation(float yaw, float pitch, float roll, bool bInvertTurnInput) { NativeCall<void, float, float, float, bool>(this, "AShooterPlayerController.ClientStartSurfaceCameraForPassenger_Implementation", yaw, pitch, roll, bInvertTurnInput); }
    void ServerUnlockPerMapExplorerNote_Implementation(int ExplorerNoteIndex) { NativeCall<void, int>(this, "AShooterPlayerController.ServerUnlockPerMapExplorerNote_Implementation", ExplorerNoteIndex); }
    void UnlockExplorerNote(int ExplorerNoteIndex, const bool forceShowExplorerNoteUI) { NativeCall<void, int, const bool>(this, "AShooterPlayerController.UnlockExplorerNote", ExplorerNoteIndex, forceShowExplorerNoteUI); }
    FExplorerNoteEntry* GetExplorerNoteEntry(FExplorerNoteEntry* result, int ExplorerNoteIndex) { return NativeCall<FExplorerNoteEntry*, FExplorerNoteEntry*, int>(this, "AShooterPlayerController.GetExplorerNoteEntry", result, ExplorerNoteIndex); }
    void ClientUnlockExplorerNote_Implementation(int ExplorerNoteIndex) { NativeCall<void, int>(this, "AShooterPlayerController.ClientUnlockExplorerNote_Implementation", ExplorerNoteIndex); }
    APawn* GetResponsibleDamager(AActor* DamageCauser) { return NativeCall<APawn*, AActor*>(this, "AShooterPlayerController.GetResponsibleDamager", DamageCauser); }
    void UnlockEmote(FName EmoteName) { NativeCall<void, FName>(this, "AShooterPlayerController.UnlockEmote", EmoteName); }
    void LockEmote(FName EmoteName) { NativeCall<void, FName>(this, "AShooterPlayerController.LockEmote", EmoteName); }
    bool IsEmoteUnlocked(FName EmoteName) { return NativeCall<bool, FName>(this, "AShooterPlayerController.IsEmoteUnlocked", EmoteName); }
    int GetCurrentMultiUseWheelCategory() { return NativeCall<int>(this, "AShooterPlayerController.GetCurrentMultiUseWheelCategory"); }
    void ClientReceiveDinoAncestors_Implementation(APrimalDinoCharacter* ForDino, TArray<FDinoAncestorsEntry>* DinoAncestors, TArray<FDinoAncestorsEntry>* DinoAncestorsMale, int RandomMutationsFemale, int RandomMutationsMale) { NativeCall<void, APrimalDinoCharacter*, TArray<FDinoAncestorsEntry>*, TArray<FDinoAncestorsEntry>*, int, int>(this, "AShooterPlayerController.ClientReceiveDinoAncestors_Implementation", ForDino, DinoAncestors, DinoAncestorsMale, RandomMutationsFemale, RandomMutationsMale); }
    void ServerRequestDinoAncestors_Implementation(APrimalDinoCharacter* ForDino) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterPlayerController.ServerRequestDinoAncestors_Implementation", 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", ItemClass, bTekGram); }
    void ClientTeleportSucceeded_Implementation(FVector TeleportLoc, FRotator TeleportRot, bool bSimpleTeleport) { NativeCall<void, FVector, FRotator, bool>(this, "AShooterPlayerController.ClientTeleportSucceeded_Implementation", TeleportLoc, TeleportRot, bSimpleTeleport); }
    bool IsAtPersonalTameLimit(bool bIsForStructure) { return NativeCall<bool, bool>(this, "AShooterPlayerController.IsAtPersonalTameLimit", 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", NewPersonalDinoTameCount); }
    void UpdatePostProcessVolumes() { NativeCall<void>(this, "AShooterPlayerController.UpdatePostProcessVolumes"); }
    bool IsSavingData() { return NativeCall<bool>(this, "AShooterPlayerController.IsSavingData"); }
    FString* PlayerCommand_Implementation(FString* result, FString* TheCommand) { return NativeCall<FString*, FString*, FString*>(this, "AShooterPlayerController.PlayerCommand_Implementation", result, TheCommand); }
    void DoPlayerCommand(FString TheCommand) { NativeCall<void, FString>(this, "AShooterPlayerController.DoPlayerCommand", TheCommand); }
    void SetControllerGamepadActive(bool bIsActive) { NativeCall<void, bool>(this, "AShooterPlayerController.SetControllerGamepadActive", bIsActive); }
    void TryToForceUploadCharacter_Implementation() { NativeCall<void>(this, "AShooterPlayerController.TryToForceUploadCharacter_Implementation"); }
    void ServerDPC_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerDPC_Implementation"); }
    bool ShouldHideGameplayUI() { return NativeCall<bool>(this, "AShooterPlayerController.ShouldHideGameplayUI"); }
    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(TArray<unsigned int>* OnlinePlayerIDs) { NativeCall<void, TArray<unsigned int>*>(this, "AShooterPlayerController.ClientReceiveMyTribeOnlineList_Implementation", OnlinePlayerIDs); }
    void ClientNotifyUnlockHairStyleOrEmote_Implementation(FName HairstyleOrEmoteName) { NativeCall<void, FName>(this, "AShooterPlayerController.ClientNotifyUnlockHairStyleOrEmote_Implementation", HairstyleOrEmoteName); }
    void UpdateRequestEquippedItemsQueue() { NativeCall<void>(this, "AShooterPlayerController.UpdateRequestEquippedItemsQueue"); }
    void SetGamma1() { NativeCall<void>(this, "AShooterPlayerController.SetGamma1"); }
    void SetGamma2() { NativeCall<void>(this, "AShooterPlayerController.SetGamma2"); }
    void ClientRequestSpectatorLocationAndRotation_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientRequestSpectatorLocationAndRotation_Implementation"); }
    void ServerRecieveSpectatorLocationAndRotation_Implementation(FVector spectatorLocation, FRotator spectatorRotation) { NativeCall<void, FVector, FRotator>(this, "AShooterPlayerController.ServerRecieveSpectatorLocationAndRotation_Implementation", spectatorLocation, spectatorRotation); }
    void ServerDropAllNotReadyForUploadItems_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerDropAllNotReadyForUploadItems_Implementation"); }
    void ClientOnDropAllNotReadyForUploadItemsFinished_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientOnDropAllNotReadyForUploadItemsFinished_Implementation"); }
    void QueueRequestEquippedItems(UPrimalInventoryComponent* invComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.QueueRequestEquippedItems", invComp); }
    void IncrementPrimalStats(EPrimalStatsValueTypes::Type statsValueType) { NativeCall<void, EPrimalStatsValueTypes::Type>(this, "AShooterPlayerController.IncrementPrimalStats", statsValueType); }
    void FlushPrimalStats() { NativeCall<void>(this, "AShooterPlayerController.FlushPrimalStats"); }
    TArray<AActor*>* GetAlwaysReleventNetworkActors() { return NativeCall<TArray<AActor*>*>(this, "AShooterPlayerController.GetAlwaysReleventNetworkActors"); }
    void SetInstantHarvest(bool bEnable) { NativeCall<void, bool>(this, "AShooterPlayerController.SetInstantHarvest", bEnable); }
    bool HasInstantHarvest() { return NativeCall<bool>(this, "AShooterPlayerController.HasInstantHarvest"); }
    AShooterCharacter* GetControllerPlayer() { return NativeCall<AShooterCharacter*>(this, "AShooterPlayerController.GetControllerPlayer"); }
    void Client_ReceiveBuffFromDayCycle_Implementation(TSubclassOf<APrimalBuff> GiveBuffClass, ADayCycleManager* FromDayCycle) { NativeCall<void, TSubclassOf<APrimalBuff>, ADayCycleManager*>(this, "AShooterPlayerController.Client_ReceiveBuffFromDayCycle_Implementation", GiveBuffClass, FromDayCycle); }
    void Tick_UpdatePings(const float DeltaTime) { NativeCall<void, const float>(this, "AShooterPlayerController.Tick_UpdatePings", DeltaTime); }
    void OnPingDown() { NativeCall<void>(this, "AShooterPlayerController.OnPingDown"); }
    void OnPingUp() { NativeCall<void>(this, "AShooterPlayerController.OnPingUp"); }
    bool DoPingTrace(FReplicatePingData* NewPing, bool* bIsResponding) { return NativeCall<bool, FReplicatePingData*, bool*>(this, "AShooterPlayerController.DoPingTrace", NewPing, bIsResponding); }
    bool CanPingPlayer(AShooterCharacter* ForPlayer) { return NativeCall<bool, AShooterCharacter*>(this, "AShooterPlayerController.CanPingPlayer", ForPlayer); }
    void Server_Ping_Implementation(FReplicatePingData WithPingData) { NativeCall<void, FReplicatePingData>(this, "AShooterPlayerController.Server_Ping_Implementation", WithPingData); }
    void PingNearbyPlayers(FReplicatePingData* WithPingData) { NativeCall<void, FReplicatePingData*>(this, "AShooterPlayerController.PingNearbyPlayers", WithPingData); }
    void Client_ReceivePing_Implementation(FReplicatePingData ReceivedPingData) { NativeCall<void, FReplicatePingData>(this, "AShooterPlayerController.Client_ReceivePing_Implementation", ReceivedPingData); }
    void Server_RespondToPing_Implementation(FReplicatePingData RespondToPingData) { NativeCall<void, FReplicatePingData>(this, "AShooterPlayerController.Server_RespondToPing_Implementation", RespondToPingData); }
    void RespondToPing(FReplicatePingData* RespondToPingData) { NativeCall<void, FReplicatePingData*>(this, "AShooterPlayerController.RespondToPing", RespondToPingData); }
    void Client_ReceivePingResponse_Implementation(FReplicatePingData ResponseData, AShooterCharacter* RespondingPlayer) { NativeCall<void, FReplicatePingData, AShooterCharacter*>(this, "AShooterPlayerController.Client_ReceivePingResponse_Implementation", ResponseData, RespondingPlayer); }
    bool InitPing(FPingData* ForPingData, FReplicatePingData* InitFromData) { return NativeCall<bool, FPingData*, FReplicatePingData*>(this, "AShooterPlayerController.InitPing", ForPingData, InitFromData); }
    UTexture2D* GetPingIconForComponent(UPrimitiveComponent* ForComponent) { return NativeCall<UTexture2D*, UPrimitiveComponent*>(this, "AShooterPlayerController.GetPingIconForComponent", ForComponent); }
    static FString* GetPingTitleForActor(FString* result, AActor* ForActor) { return NativeCall<FString*, FString*, AActor*>(nullptr, "AShooterPlayerController.GetPingTitleForActor", result, ForActor); }
    static bool IsPlayerViewingPing(AShooterPlayerController* ForPC, FPingData* CheckPingData) { return NativeCall<bool, AShooterPlayerController*, FPingData*>(nullptr, "AShooterPlayerController.IsPlayerViewingPing", ForPC, CheckPingData); }
    static bool DoesPlayerOwnPing(AShooterPlayerController* PlayerPC, const unsigned int PingOwnerID) { return NativeCall<bool, AShooterPlayerController*, const unsigned int>(nullptr, "AShooterPlayerController.DoesPlayerOwnPing", PlayerPC, PingOwnerID); }
    static bool IsPingedItem(UPrimitiveComponent* PingComponent) { return NativeCall<bool, UPrimitiveComponent*>(nullptr, "AShooterPlayerController.IsPingedItem", PingComponent); }
    TArray<FPointOfInterestData_ForCompanion>* GetNearbyPOIs(TArray<FPointOfInterestData_ForCompanion>* result) { return NativeCall<TArray<FPointOfInterestData_ForCompanion>*, TArray<FPointOfInterestData_ForCompanion>*>(this, "AShooterPlayerController.GetNearbyPOIs", result); }
    void Tick_SearchForPOIs(float DeltaTime) { NativeCall<void, float>(this, "AShooterPlayerController.Tick_SearchForPOIs", DeltaTime); }
    void SetMissionWaypointInfo(FString InWaypointTitle, FVector InWaypointDestination, FName InWaypointID) { NativeCall<void, FString, FVector, FName>(this, "AShooterPlayerController.SetMissionWaypointInfo", InWaypointTitle, InWaypointDestination, InWaypointID); }
    void SetMissionWaypointVisible(bool bInIsVisible) { NativeCall<void, bool>(this, "AShooterPlayerController.SetMissionWaypointVisible", bInIsVisible); }
    bool GetIsMissionWaypointActive() { return NativeCall<bool>(this, "AShooterPlayerController.GetIsMissionWaypointActive"); }
    FName* GetMissionWaypointID(FName* result) { return NativeCall<FName*, FName*>(this, "AShooterPlayerController.GetMissionWaypointID", result); }
    void NotifyPawnBuffsOfDamageEvent(AActor* DamagedActor, float DamageAmount, FDamageEvent* DamageEvent) { NativeCall<void, AActor*, float, FDamageEvent*>(this, "AShooterPlayerController.NotifyPawnBuffsOfDamageEvent", DamagedActor, DamageAmount, DamageEvent); }
    void RetryLoginToVivox() { NativeCall<void>(this, "AShooterPlayerController.RetryLoginToVivox"); }
    void RetryJoinVivoxChannel() { NativeCall<void>(this, "AShooterPlayerController.RetryJoinVivoxChannel"); }
    void ClearVivoxRetryTimers() { NativeCall<void>(this, "AShooterPlayerController.ClearVivoxRetryTimers"); }
    void ClearVivoxRetryCounters() { NativeCall<void>(this, "AShooterPlayerController.ClearVivoxRetryCounters"); }
    void ServerLoginToVivox_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerLoginToVivox_Implementation"); }
    void ClientLoginToVivox_Implementation(FString* VivoxUsername) { NativeCall<void, FString*>(this, "AShooterPlayerController.ClientLoginToVivox_Implementation", VivoxUsername); }
    void ServerSuccessfullyLoggedIntoVivox_Implementation(FString* LoginSessionUserUri) { NativeCall<void, FString*>(this, "AShooterPlayerController.ServerSuccessfullyLoggedIntoVivox_Implementation", LoginSessionUserUri); }
    void ClientJoinVivoxChannel_Implementation(FString* LoginSessionUserUri, FString* ChannelName, int AtlasVoiceChannelTypeAsInt, int AttenuationModelAsInt32, float MaxDistance, float MinDistance, float Rolloff) { NativeCall<void, FString*, FString*, int, int, float, float, float>(this, "AShooterPlayerController.ClientJoinVivoxChannel_Implementation", LoginSessionUserUri, ChannelName, AtlasVoiceChannelTypeAsInt, AttenuationModelAsInt32, MaxDistance, MinDistance, Rolloff); }
    void Update3DPosition(bool ForceUpdate) { NativeCall<void, bool>(this, "AShooterPlayerController.Update3DPosition", ForceUpdate); }
    bool Get3DValuesAreDirty() { return NativeCall<bool>(this, "AShooterPlayerController.Get3DValuesAreDirty"); }
    void Clear3DValuesAreDirty() { NativeCall<void>(this, "AShooterPlayerController.Clear3DValuesAreDirty"); }
    static void StaticRegisterNativesAShooterPlayerController() { NativeCall<void>(nullptr, "AShooterPlayerController.StaticRegisterNativesAShooterPlayerController"); }
    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "AShooterPlayerController.GetPrivateStaticClass", Package); }
    FVector* BPCheckCanDinoSpawnFromLocation(FVector* result, TSubclassOf<APrimalDinoCharacter> DinoClass, FVector* CheckLocation) { return NativeCall<FVector*, FVector*, TSubclassOf<APrimalDinoCharacter>, FVector*>(this, "AShooterPlayerController.BPCheckCanDinoSpawnFromLocation", result, DinoClass, CheckLocation); }
    void CheckCheatsPassword(FString* pass) { NativeCall<void, FString*>(this, "AShooterPlayerController.CheckCheatsPassword", pass); }
    void CheckRequestSpectator(FString* InSpectatorPass) { NativeCall<void, FString*>(this, "AShooterPlayerController.CheckRequestSpectator", InSpectatorPass); }
    void Client_ReceiveBuffFromDayCycle(TSubclassOf<APrimalBuff> GiveBuffClass, ADayCycleManager* FromDayCycle) { NativeCall<void, TSubclassOf<APrimalBuff>, ADayCycleManager*>(this, "AShooterPlayerController.Client_ReceiveBuffFromDayCycle", GiveBuffClass, FromDayCycle); }
    void Client_ReceivePing(FReplicatePingData ReceivedPingData) { NativeCall<void, FReplicatePingData>(this, "AShooterPlayerController.Client_ReceivePing", ReceivedPingData); }
    void Client_ReceivePingResponse(FReplicatePingData ResponseData, AShooterCharacter* RespondingPlayer) { NativeCall<void, FReplicatePingData, AShooterCharacter*>(this, "AShooterPlayerController.Client_ReceivePingResponse", ResponseData, RespondingPlayer); }
    void ClientAddActorItem(UPrimalInventoryComponent* forInventory, FItemNetInfo itemInfo, bool bEquipItem, bool ShowHUDNotification) { NativeCall<void, UPrimalInventoryComponent*, FItemNetInfo, bool, bool>(this, "AShooterPlayerController.ClientAddActorItem", forInventory, itemInfo, bEquipItem, ShowHUDNotification); }
    void ClientAddActorItemToFolder(UPrimalInventoryComponent* forInventory, FItemNetInfo itemInfo, bool bEquipItem, bool ShowHUDNotification, FString* ToFolder) { NativeCall<void, UPrimalInventoryComponent*, FItemNetInfo, bool, bool, FString*>(this, "AShooterPlayerController.ClientAddActorItemToFolder", forInventory, itemInfo, bEquipItem, ShowHUDNotification, ToFolder); }
    void ClientAddFloatingDamageText(FVector_NetQuantize AtLocation, int DamageAmount, int FromTeamID) { NativeCall<void, FVector_NetQuantize, int, int>(this, "AShooterPlayerController.ClientAddFloatingDamageText", AtLocation, DamageAmount, FromTeamID); }
    void ClientAddFloatingText(FVector_NetQuantize AtLocation, FString* FloatingTextString, FColor FloatingTextColor, float ScaleX, float ScaleY, float TextLifeSpan, FVector TextVelocity, float MinScale, float FadeInTime, float FadeOutTime) { NativeCall<void, FVector_NetQuantize, FString*, FColor, float, float, float, FVector, float, float, float>(this, "AShooterPlayerController.ClientAddFloatingText", AtLocation, FloatingTextString, FloatingTextColor, ScaleX, ScaleY, TextLifeSpan, TextVelocity, MinScale, FadeInTime, FadeOutTime); }
    void ClientAddFolderToInventoryComponent(UPrimalInventoryComponent* forInventory, FString* NewCustomFolderName, int InventoryCompType) { NativeCall<void, UPrimalInventoryComponent*, FString*, int>(this, "AShooterPlayerController.ClientAddFolderToInventoryComponent", forInventory, NewCustomFolderName, InventoryCompType); }
    void ClientAddItemToArk(UPrimalInventoryComponent* forInventory, FItemNetInfo itemInfo, bool bFromLoad) { NativeCall<void, UPrimalInventoryComponent*, FItemNetInfo, bool>(this, "AShooterPlayerController.ClientAddItemToArk", forInventory, itemInfo, bFromLoad); }
    void ClientChatMessage(FChatMessage Chat) { NativeCall<void, FChatMessage>(this, "AShooterPlayerController.ClientChatMessage", Chat); }
    void ClientCollectedAchievementItem(TSubclassOf<UPrimalItem> ItemClass) { NativeCall<void, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerController.ClientCollectedAchievementItem", ItemClass); }
    void ClientDoMultiUse(UObject* ForObject, int useIndex) { NativeCall<void, UObject*, int>(this, "AShooterPlayerController.ClientDoMultiUse", ForObject, useIndex); }
    void ClientDownloadDinoRequestFinished(bool Success) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientDownloadDinoRequestFinished", Success); }
    void ClientDownloadPlayerCharacterRequestFinished(bool Success) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientDownloadPlayerCharacterRequestFinished", Success); }
    void ClientEndReceivingTribeLog() { NativeCall<void>(this, "AShooterPlayerController.ClientEndReceivingTribeLog"); }
    void ClientFailedRemoveSaddle() { NativeCall<void>(this, "AShooterPlayerController.ClientFailedRemoveSaddle"); }
    void ClientFailedToAddItemFromArkInventory() { NativeCall<void>(this, "AShooterPlayerController.ClientFailedToAddItemFromArkInventory"); }
    void ClientFinishedLoadArkItems(UPrimalInventoryComponent* forInventory) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ClientFinishedLoadArkItems", forInventory); }
    void ClientFinishedReceivingActorItems(UPrimalInventoryComponent* forInventory, bool bEquippedItems) { NativeCall<void, UPrimalInventoryComponent*, bool>(this, "AShooterPlayerController.ClientFinishedReceivingActorItems", forInventory, bEquippedItems); }
    void ClientGetMessageOfTheDay(FString* Message) { NativeCall<void, FString*>(this, "AShooterPlayerController.ClientGetMessageOfTheDay", Message); }
    void ClientHUDNotificationTypeParams(int MessageType, int MessageType1, int MessageParam2, UObject* ObjectParam1) { NativeCall<void, int, int, int, UObject*>(this, "AShooterPlayerController.ClientHUDNotificationTypeParams", MessageType, MessageType1, MessageParam2, ObjectParam1); }
    void ClientInsertActorItem(UPrimalInventoryComponent* forInventory, FItemNetInfo itemInfo, FItemNetID InsertAfterItemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetInfo, FItemNetID>(this, "AShooterPlayerController.ClientInsertActorItem", forInventory, itemInfo, InsertAfterItemID); }
    void ClientJoinVivoxChannel(FString* LoginSessionUserUri, FString* ChannelName, int AtlasChannelTypeAsInt, int AttenuationModelAsInt32, float MaxDistance, float MinDistance, float Rolloff) { NativeCall<void, FString*, FString*, int, int, float, float, float>(this, "AShooterPlayerController.ClientJoinVivoxChannel", LoginSessionUserUri, ChannelName, AtlasChannelTypeAsInt, AttenuationModelAsInt32, MaxDistance, MinDistance, Rolloff); }
    void ClientLoadArkItems(UPrimalInventoryComponent* forInventory, TArray<FItemNetInfo>* itemInfos, bool bClear, bool bFinalBatch) { NativeCall<void, UPrimalInventoryComponent*, TArray<FItemNetInfo>*, bool, bool>(this, "AShooterPlayerController.ClientLoadArkItems", forInventory, itemInfos, bClear, bFinalBatch); }
    void ClientLoginToVivox(FString* VivoxUsername) { NativeCall<void, FString*>(this, "AShooterPlayerController.ClientLoginToVivox", VivoxUsername); }
    void ClientNotifyAdmin() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyAdmin"); }
    void ClientNotifyCantHarvest() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyCantHarvest"); }
    void ClientNotifyCantHitHarvest() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyCantHitHarvest"); }
    void ClientNotifyDefeatedDino(TSubclassOf<APrimalDinoCharacter> DinoClass) { NativeCall<void, TSubclassOf<APrimalDinoCharacter>>(this, "AShooterPlayerController.ClientNotifyDefeatedDino", DinoClass); }
    void ClientNotifyDinoDeath(FString* DinoName, FString* AttackerName, bool bIsVehicle) { NativeCall<void, FString*, FString*, bool>(this, "AShooterPlayerController.ClientNotifyDinoDeath", DinoName, AttackerName, bIsVehicle); }
    void ClientNotifyDinoKill(APrimalDinoCharacter* InstigatingPawn, APawn* VictimPawn) { NativeCall<void, APrimalDinoCharacter*, APawn*>(this, "AShooterPlayerController.ClientNotifyDinoKill", InstigatingPawn, VictimPawn); }
    void ClientNotifyEditText(TSubclassOf<UObject> ForObjectClass, unsigned int ExtraID1, unsigned int ExtraID2, UObject* ForObject) { NativeCall<void, TSubclassOf<UObject>, unsigned int, unsigned int, UObject*>(this, "AShooterPlayerController.ClientNotifyEditText", ForObjectClass, ExtraID1, ExtraID2, ForObject); }
    void ClientNotifyHitHarvest() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyHitHarvest"); }
    void ClientNotifyLevelUp(APrimalCharacter* ForChar, int NewLevel) { NativeCall<void, APrimalCharacter*, int>(this, "AShooterPlayerController.ClientNotifyLevelUp", ForChar, NewLevel); }
    void ClientNotifyListenServerOutOfRange() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyListenServerOutOfRange"); }
    void ClientNotifyMessageOfTheDay(FString* Message, float timeToDisplay) { NativeCall<void, FString*, float>(this, "AShooterPlayerController.ClientNotifyMessageOfTheDay", Message, timeToDisplay); }
    void ClientNotifyPaintFinished(bool bSuccess) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientNotifyPaintFinished", bSuccess); }
    void ClientNotifyPlayerDeath(APawn* InstigatingPawn) { NativeCall<void, APawn*>(this, "AShooterPlayerController.ClientNotifyPlayerDeath", InstigatingPawn); }
    void ClientNotifyPlayerDeathReason(FString* ReasonString) { NativeCall<void, FString*>(this, "AShooterPlayerController.ClientNotifyPlayerDeathReason", ReasonString); }
    void ClientNotifyPlayerKill(AActor* PlayerPawn, APawn* VictimPawn) { NativeCall<void, AActor*, APawn*>(this, "AShooterPlayerController.ClientNotifyPlayerKill", PlayerPawn, VictimPawn); }
    void ClientNotifyRemotePlayerDeath(FString* PlayerName, FString* AttackerName) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ClientNotifyRemotePlayerDeath", PlayerName, AttackerName); }
    void ClientNotifySummonedDino(TSubclassOf<APrimalDinoCharacter> DinoClass) { NativeCall<void, TSubclassOf<APrimalDinoCharacter>>(this, "AShooterPlayerController.ClientNotifySummonedDino", DinoClass); }
    void ClientNotifyTamedDino(TSubclassOf<APrimalDinoCharacter> DinoClass) { NativeCall<void, TSubclassOf<APrimalDinoCharacter>>(this, "AShooterPlayerController.ClientNotifyTamedDino", DinoClass); }
    void ClientNotifyTorpidityIncrease() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyTorpidityIncrease"); }
    void ClientNotifyTribeXP(float HowMuch) { NativeCall<void, float>(this, "AShooterPlayerController.ClientNotifyTribeXP", HowMuch); }
    void ClientNotifyUnlockedEngram(TSubclassOf<UPrimalItem> ItemClass, bool bTekGram) { NativeCall<void, TSubclassOf<UPrimalItem>, bool>(this, "AShooterPlayerController.ClientNotifyUnlockedEngram", ItemClass, bTekGram); }
    void ClientNotifyUnlockHairStyleOrEmote(FName HairstyleOrEmoteName) { NativeCall<void, FName>(this, "AShooterPlayerController.ClientNotifyUnlockHairStyleOrEmote", HairstyleOrEmoteName); }
    void ClientOnAddedItemsToAllClustersInventory(bool Success, FString* UserId, TArray<int>* MasterIndexNum) { NativeCall<void, bool, FString*, TArray<int>*>(this, "AShooterPlayerController.ClientOnAddedItemsToAllClustersInventory", Success, UserId, MasterIndexNum); }
    void ClientOnCurrentCharacterAndItemsUploaded(unsigned __int64 TransferringPlayerDataId) { NativeCall<void, unsigned __int64>(this, "AShooterPlayerController.ClientOnCurrentCharacterAndItemsUploaded", TransferringPlayerDataId); }
    void ClientOnDropAllNotReadyForUploadItemsFinished() { NativeCall<void>(this, "AShooterPlayerController.ClientOnDropAllNotReadyForUploadItemsFinished"); }
    void ClientOnEndDownloadTransferredPlayerCharacter(bool Success, int FailureResponseCode, FString* FailureResponseMessage) { NativeCall<void, bool, int, FString*>(this, "AShooterPlayerController.ClientOnEndDownloadTransferredPlayerCharacter", Success, FailureResponseCode, FailureResponseMessage); }
    void ClientOnStartDownloadTransferredPlayerCharacter() { NativeCall<void>(this, "AShooterPlayerController.ClientOnStartDownloadTransferredPlayerCharacter"); }
    void ClientPlayerIsValidToDownload(bool bIsValid, FArkTributePlayerData PlayerData) { NativeCall<void, bool, FArkTributePlayerData>(this, "AShooterPlayerController.ClientPlayerIsValidToDownload", bIsValid, PlayerData); }
    void ClientPlayLocalSound(USoundBase* aSound, bool bAttach) { NativeCall<void, USoundBase*, bool>(this, "AShooterPlayerController.ClientPlayLocalSound", aSound, bAttach); }
    void ClientReceiveDinoAncestors(APrimalDinoCharacter* ForDino, TArray<FDinoAncestorsEntry>* DinoAncestors, TArray<FDinoAncestorsEntry>* DinoAncestorsMale, int RandomMutationsFemale, int RandomMutationsMale) { NativeCall<void, APrimalDinoCharacter*, TArray<FDinoAncestorsEntry>*, TArray<FDinoAncestorsEntry>*, int, int>(this, "AShooterPlayerController.ClientReceiveDinoAncestors", ForDino, DinoAncestors, DinoAncestorsMale, RandomMutationsFemale, RandomMutationsMale); }
    void ClientReceiveDinoCharStats(APrimalDinoCharacter* theDinoChar, TArray<float>* CurValues, TArray<float>* MaxValues) { NativeCall<void, APrimalDinoCharacter*, TArray<float>*, TArray<float>*>(this, "AShooterPlayerController.ClientReceiveDinoCharStats", theDinoChar, CurValues, MaxValues); }
    void ClientReceiveMyTribeOnlineList(TArray<unsigned int>* OnlinePlayerIDs) { NativeCall<void, TArray<unsigned int>*>(this, "AShooterPlayerController.ClientReceiveMyTribeOnlineList", OnlinePlayerIDs); }
    void ClientReceiveOriginalHairColor(FLinearColor HairColor) { NativeCall<void, FLinearColor>(this, "AShooterPlayerController.ClientReceiveOriginalHairColor", HairColor); }
    void ClientReceiveTribeLog(FString* LogString) { NativeCall<void, FString*>(this, "AShooterPlayerController.ClientReceiveTribeLog", LogString); }
    void ClientRefreshSteamInventoryFinished(bool bSuccess) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientRefreshSteamInventoryFinished", bSuccess); }
    void ClientRemoveActorItem(UPrimalInventoryComponent* forInventory, FItemNetID itemID, bool showHUDMessage) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, bool>(this, "AShooterPlayerController.ClientRemoveActorItem", forInventory, itemID, showHUDMessage); }
    void ClientRemoveItemFromArk(UPrimalInventoryComponent* forInventory, FItemNetID RemovedItemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ClientRemoveItemFromArk", forInventory, RemovedItemID); }
    void ClientRemoveItemFromSteamInventory(TArray<unsigned __int64>* ItemSteamUserID, int Quantity) { NativeCall<void, TArray<unsigned __int64>*, int>(this, "AShooterPlayerController.ClientRemoveItemFromSteamInventory", ItemSteamUserID, Quantity); }
    void ClientRequestSpectatorLocationAndRotation() { NativeCall<void>(this, "AShooterPlayerController.ClientRequestSpectatorLocationAndRotation"); }
    void ClientResetRespawningFlag() { NativeCall<void>(this, "AShooterPlayerController.ClientResetRespawningFlag"); }
    void ClientRunLocalConsoleCommand(FString* Command, bool bWriteToLog) { NativeCall<void, FString*, bool>(this, "AShooterPlayerController.ClientRunLocalConsoleCommand", Command, bWriteToLog); }
    void ClientSendArkDataPayload(FGuid ID, EPrimalARKTributeDataType::Type ArkDataType, TArray<unsigned char>* DataBytes) { NativeCall<void, FGuid, EPrimalARKTributeDataType::Type, TArray<unsigned char>*>(this, "AShooterPlayerController.ClientSendArkDataPayload", ID, ArkDataType, DataBytes); }
    void ClientSendArkDataPayloadBegin(FGuid ID, EPrimalARKTributeDataType::Type ArkDataType, FString* DataClass, FString* TagName, FString* Name, TArray<FString>* DataStats, unsigned int ID1, unsigned int ID2) { NativeCall<void, FGuid, EPrimalARKTributeDataType::Type, FString*, FString*, FString*, TArray<FString>*, unsigned int, unsigned int>(this, "AShooterPlayerController.ClientSendArkDataPayloadBegin", ID, ArkDataType, DataClass, TagName, Name, DataStats, ID1, ID2); }
    void ClientSendArkDataPayloadEnd(FGuid ID, EPrimalARKTributeDataType::Type ArkDataType, unsigned __int64 PlayerDataID) { NativeCall<void, FGuid, EPrimalARKTributeDataType::Type, unsigned __int64>(this, "AShooterPlayerController.ClientSendArkDataPayloadEnd", ID, ArkDataType, PlayerDataID); }
    void ClientServerChatDirectMessage(FString* MessageText, FLinearColor MessageColor, bool bIsBold) { NativeCall<void, FString*, FLinearColor, bool>(this, "AShooterPlayerController.ClientServerChatDirectMessage", MessageText, MessageColor, bIsBold); }
    void ClientServerChatMessage(FString* MessageText, FLinearColor MessageColor, bool bIsBold) { NativeCall<void, FString*, FLinearColor, bool>(this, "AShooterPlayerController.ClientServerChatMessage", MessageText, MessageColor, bIsBold); }
    void ClientServerNotification(FString* MessageText, FLinearColor MessageColor, float DisplayScale, float DisplayTime, UTexture2D* MessageIcon, USoundBase* SoundToPlay) { NativeCall<void, FString*, FLinearColor, float, float, UTexture2D*, USoundBase*>(this, "AShooterPlayerController.ClientServerNotification", MessageText, MessageColor, DisplayScale, DisplayTime, MessageIcon, SoundToPlay); }
    void ClientServerNotificationSingle(FString* MessageText, FLinearColor MessageColor, float DisplayScale, float DisplayTime, UTexture2D* MessageIcon, USoundBase* SoundToPlay, int MessageTypeID) { NativeCall<void, FString*, FLinearColor, float, float, UTexture2D*, USoundBase*, int>(this, "AShooterPlayerController.ClientServerNotificationSingle", MessageText, MessageColor, DisplayScale, DisplayTime, MessageIcon, SoundToPlay, MessageTypeID); }
    void ClientServerSOTFNotificationCustom(FString* MessageText, FLinearColor MessageColor, float DisplayScale, float DisplayTime, UTexture2D* MessageIcon, USoundBase* SoundToPlay) { NativeCall<void, FString*, FLinearColor, float, float, UTexture2D*, USoundBase*>(this, "AShooterPlayerController.ClientServerSOTFNotificationCustom", MessageText, MessageColor, DisplayScale, DisplayTime, MessageIcon, SoundToPlay); }
    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", LimitItems, LimitDinos, LimitCharacters, MaxItems, MaxDinos, MaxCharacters); }
    void ClientSetControlRotation(FRotator NewRotation) { NativeCall<void, FRotator>(this, "AShooterPlayerController.ClientSetControlRotation", NewRotation); }
    void ClientSetHUDAndInitUIScenes(TSubclassOf<AHUD> NewHUDClass) { NativeCall<void, TSubclassOf<AHUD>>(this, "AShooterPlayerController.ClientSetHUDAndInitUIScenes", NewHUDClass); }
    void ClientSetPersonalDinoTameCount(int NewPersonalDinoTameCount) { NativeCall<void, int>(this, "AShooterPlayerController.ClientSetPersonalDinoTameCount", NewPersonalDinoTameCount); }
    void ClientSetSpectatorLocation(FVector NewLocation) { NativeCall<void, FVector>(this, "AShooterPlayerController.ClientSetSpectatorLocation", NewLocation); }
    void ClientShowCharacterCreationUI(bool bShowDownloadCharacter) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientShowCharacterCreationUI", bShowDownloadCharacter); }
    void ClientShowLeaderboard(TSubclassOf<ULeaderboard> LeaderboardType, FName MissionTag, TArray<FLeaderboardRow>* LeaderboardRows, bool bPlayerHasValidLatestScore, FLeaderboardRow LatestPlayerScore) { NativeCall<void, TSubclassOf<ULeaderboard>, FName, TArray<FLeaderboardRow>*, bool, FLeaderboardRow>(this, "AShooterPlayerController.ClientShowLeaderboard", LeaderboardType, MissionTag, LeaderboardRows, bPlayerHasValidLatestScore, LatestPlayerScore); }
    void ClientShowPaintingUI(UObject* ObjectToPaint) { NativeCall<void, UObject*>(this, "AShooterPlayerController.ClientShowPaintingUI", ObjectToPaint); }
    void ClientShowSpawnUI(float Delay) { NativeCall<void, float>(this, "AShooterPlayerController.ClientShowSpawnUI", Delay); }
    void ClientShowSpawnUIForTransferringPlayer(TSubclassOf<AHUD> NewHUDClass, unsigned __int64 TransferingPlayerID, bool bUseTimer) { NativeCall<void, TSubclassOf<AHUD>, unsigned __int64, bool>(this, "AShooterPlayerController.ClientShowSpawnUIForTransferringPlayer", NewHUDClass, TransferingPlayerID, bUseTimer); }
    void ClientShowTransferredPlayerConfirmationDialog() { NativeCall<void>(this, "AShooterPlayerController.ClientShowTransferredPlayerConfirmationDialog"); }
    void ClientStartReceivingActorItems(UPrimalInventoryComponent* forInventory, bool bEquippedItems) { NativeCall<void, UPrimalInventoryComponent*, bool>(this, "AShooterPlayerController.ClientStartReceivingActorItems", forInventory, bEquippedItems); }
    void ClientStartReceivingTribeLog() { NativeCall<void>(this, "AShooterPlayerController.ClientStartReceivingTribeLog"); }
    void ClientStartSurfaceCameraForPassenger(float yaw, float pitch, float roll, bool bInvertTurnInput) { NativeCall<void, float, float, float, bool>(this, "AShooterPlayerController.ClientStartSurfaceCameraForPassenger", yaw, pitch, roll, bInvertTurnInput); }
    void ClientStopLocalSound(USoundBase* aSound) { NativeCall<void, USoundBase*>(this, "AShooterPlayerController.ClientStopLocalSound", aSound); }
    void ClientSwapActorItems(UPrimalInventoryComponent* forInventory, FItemNetID itemID1, FItemNetID itemID2) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, FItemNetID>(this, "AShooterPlayerController.ClientSwapActorItems", forInventory, itemID1, itemID2); }
    void ClientTeleportSpectator(FVector Location, unsigned __int64 PlayerID) { NativeCall<void, FVector, unsigned __int64>(this, "AShooterPlayerController.ClientTeleportSpectator", Location, PlayerID); }
    void ClientUnlockAchievement(FString* AchievementID) { NativeCall<void, FString*>(this, "AShooterPlayerController.ClientUnlockAchievement", AchievementID); }
    void ClientUnlockExplorerNote(int ExplorerNoteIndex) { NativeCall<void, int>(this, "AShooterPlayerController.ClientUnlockExplorerNote", ExplorerNoteIndex); }
    void ClientUpdateInventoryCraftQueue(UPrimalInventoryComponent* forInventory, TArray<FItemCraftQueueEntry>* CraftQueueEntries) { NativeCall<void, UPrimalInventoryComponent*, TArray<FItemCraftQueueEntry>*>(this, "AShooterPlayerController.ClientUpdateInventoryCraftQueue", forInventory, CraftQueueEntries); }
    void ClientUpdateItemDurability(UPrimalInventoryComponent* forInventory, FItemNetID itemID, float ItemDurability) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, float>(this, "AShooterPlayerController.ClientUpdateItemDurability", forInventory, itemID, ItemDurability); }
    void ClientUpdateItemQuantity(UPrimalInventoryComponent* forInventory, FItemNetID itemID, int ItemQuantity) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, int>(this, "AShooterPlayerController.ClientUpdateItemQuantity", forInventory, itemID, ItemQuantity); }
    void ClientUpdateItemWeaponClipAmmo(UPrimalInventoryComponent* forInventory, FItemNetID itemID, int Ammo) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, int>(this, "AShooterPlayerController.ClientUpdateItemWeaponClipAmmo", forInventory, itemID, Ammo); }
    void ClientUploadedCharactersLoaded(bool Success, TArray<FArkTributePlayerDataListing>* UploadedCharactersDataListings) { NativeCall<void, bool, TArray<FArkTributePlayerDataListing>*>(this, "AShooterPlayerController.ClientUploadedCharactersLoaded", Success, UploadedCharactersDataListings); }
    void ClientUploadedDinosLoaded(TArray<FARKTributeDinoListing>* UploadedDinosDataListings) { NativeCall<void, TArray<FARKTributeDinoListing>*>(this, "AShooterPlayerController.ClientUploadedDinosLoaded", UploadedDinosDataListings); }
    void ClientUsedActorItem(UPrimalInventoryComponent* forInventory, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ClientUsedActorItem", forInventory, itemID); }
    void DoServerCheckUnfreeze() { NativeCall<void>(this, "AShooterPlayerController.DoServerCheckUnfreeze"); }
    void InitCharacterPainting(APrimalCharacter* Char) { NativeCall<void, APrimalCharacter*>(this, "AShooterPlayerController.InitCharacterPainting", Char); }
    void NotifyTribeWarStatus(FString* EnemyTribeString, int StatusType) { NativeCall<void, FString*, int>(this, "AShooterPlayerController.NotifyTribeWarStatus", EnemyTribeString, StatusType); }
    void OnDisableSpectator() { NativeCall<void>(this, "AShooterPlayerController.OnDisableSpectator"); }
    FString* PlayerCommand(FString* result, FString* TheCommand) { return NativeCall<FString*, FString*, FString*>(this, "AShooterPlayerController.PlayerCommand", result, TheCommand); }
    void PlayHitMarkerStructure() { NativeCall<void>(this, "AShooterPlayerController.PlayHitMarkerStructure"); }
    void PlayHitMarkerStructureAlly() { NativeCall<void>(this, "AShooterPlayerController.PlayHitMarkerStructureAlly"); }
    void RPCStayAlive() { NativeCall<void>(this, "AShooterPlayerController.RPCStayAlive"); }
    void Server_Ping(FReplicatePingData WithPingData) { NativeCall<void, FReplicatePingData>(this, "AShooterPlayerController.Server_Ping", WithPingData); }
    void Server_RespondToPing(FReplicatePingData RespondToPingData) { NativeCall<void, FReplicatePingData>(this, "AShooterPlayerController.Server_RespondToPing", RespondToPingData); }
    void ServerActorCloseRemoteInventory(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerActorCloseRemoteInventory", inventoryComp); }
    void ServerActorViewRemoteInventory(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerActorViewRemoteInventory", inventoryComp); }
    void ServerAddAchievementID(FString* AchievementID, bool bIsOnSpawn) { NativeCall<void, FString*, bool>(this, "AShooterPlayerController.ServerAddAchievementID", AchievementID, bIsOnSpawn); }
    void ServerAddItemFromArkInventory(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, int requestedQuantity) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, int>(this, "AShooterPlayerController.ServerAddItemFromArkInventory", inventoryComp, itemID, requestedQuantity); }
    void ServerAddItemToArkInventory(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, int requestedQuantity) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, int>(this, "AShooterPlayerController.ServerAddItemToArkInventory", inventoryComp, itemID, requestedQuantity); }
    void ServerAddItemToCustomFolder(UPrimalInventoryComponent* forInventory, FString* CFolderName, int InventoryCompType, FItemNetID ItemId) { NativeCall<void, UPrimalInventoryComponent*, FString*, int, FItemNetID>(this, "AShooterPlayerController.ServerAddItemToCustomFolder", forInventory, CFolderName, InventoryCompType, ItemId); }
    void ServerAllowPlayerToJoinNoCheck(FString* PlayerId) { NativeCall<void, FString*>(this, "AShooterPlayerController.ServerAllowPlayerToJoinNoCheck", PlayerId); }
    void ServerAsyncLoadArkInventoryItems(TArray<FItemNetInfo>* ArkInventoryItems, bool bFinalBatch) { NativeCall<void, TArray<FItemNetInfo>*, bool>(this, "AShooterPlayerController.ServerAsyncLoadArkInventoryItems", ArkInventoryItems, bFinalBatch); }
    void ServerBanPlayer(FString* PlayerSteamName, FString* PlayerSteamID) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ServerBanPlayer", PlayerSteamName, PlayerSteamID); }
    void ServerCharacterUploadWithItems_CharaterPayload(unsigned __int64 PlayerDataId, TArray<unsigned char>* PlayerDataChunk) { NativeCall<void, unsigned __int64, TArray<unsigned char>*>(this, "AShooterPlayerController.ServerCharacterUploadWithItems_CharaterPayload", PlayerDataId, PlayerDataChunk); }
    void ServerCharacterUploadWithItems_FinishAndCreateCharacter(unsigned __int64 PlayerDataId) { NativeCall<void, unsigned __int64>(this, "AShooterPlayerController.ServerCharacterUploadWithItems_FinishAndCreateCharacter", PlayerDataId); }
    void ServerCharacterUploadWithItems_Start(unsigned __int64 PlayerDataId, FArkTributePlayerData PlayerData) { NativeCall<void, unsigned __int64, FArkTributePlayerData>(this, "AShooterPlayerController.ServerCharacterUploadWithItems_Start", PlayerDataId, PlayerData); }
    void ServerCharacterUploadWithItems_UploadItem(unsigned __int64 PlayerDataId, FItemNetInfo InvItem) { NativeCall<void, unsigned __int64, FItemNetInfo>(this, "AShooterPlayerController.ServerCharacterUploadWithItems_UploadItem", PlayerDataId, InvItem); }
    void ServerCheckUnfreeze() { NativeCall<void>(this, "AShooterPlayerController.ServerCheckUnfreeze"); }
    void ServerCraftItem(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerCraftItem", inventoryComp, itemID); }
    void ServerCycleSpectator(bool bNext) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerCycleSpectator", bNext); }
    void ServerDeleteCustomFolder(UPrimalInventoryComponent* forInventory, FString* CFolderName, int InventoryCompType) { NativeCall<void, UPrimalInventoryComponent*, FString*, int>(this, "AShooterPlayerController.ServerDeleteCustomFolder", forInventory, CFolderName, InventoryCompType); }
    void ServerDeleteItemFromCustomFolder(UPrimalInventoryComponent* forInventory, FString* CFolderName, int InventoryCompType, FItemNetID ItemId) { NativeCall<void, UPrimalInventoryComponent*, FString*, int, FItemNetID>(this, "AShooterPlayerController.ServerDeleteItemFromCustomFolder", forInventory, CFolderName, InventoryCompType, ItemId); }
    void ServerDisallowPlayerToJoinNoCheck(FString* PlayerId) { NativeCall<void, FString*>(this, "AShooterPlayerController.ServerDisallowPlayerToJoinNoCheck", PlayerId); }
    void ServerDownloadTransferredPlayer(int spawnPointID, int spawnPointRegionIndex) { NativeCall<void, int, int>(this, "AShooterPlayerController.ServerDownloadTransferredPlayer", spawnPointID, spawnPointRegionIndex); }
    void ServerDPC() { NativeCall<void>(this, "AShooterPlayerController.ServerDPC"); }
    void ServerDropAllNotReadyForUploadItems() { NativeCall<void>(this, "AShooterPlayerController.ServerDropAllNotReadyForUploadItems"); }
    void ServerDropFromRemoteInventory(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerDropFromRemoteInventory", inventoryComp, itemID); }
    void ServerEquipPawnItem(FItemNetID itemID) { NativeCall<void, FItemNetID>(this, "AShooterPlayerController.ServerEquipPawnItem", itemID); }
    void ServerEquipToRemoteInventory(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerEquipToRemoteInventory", inventoryComp, itemID); }
    void ServerGetMessageOfTheDay() { NativeCall<void>(this, "AShooterPlayerController.ServerGetMessageOfTheDay"); }
    void ServerGetOriginalHairColor() { NativeCall<void>(this, "AShooterPlayerController.ServerGetOriginalHairColor"); }
    void ServerGlobalCommand(FString* Msg) { NativeCall<void, FString*>(this, "AShooterPlayerController.ServerGlobalCommand", Msg); }
    void ServerGrindItemInRemoteInventory(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, bool grindStack) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, bool>(this, "AShooterPlayerController.ServerGrindItemInRemoteInventory", inventoryComp, itemID, grindStack); }
    void ServerInventoryClearCraftQueue(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerInventoryClearCraftQueue", inventoryComp); }
    void ServerKickPlayer(FString* PlayerSteamName, FString* PlayerSteamID) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ServerKickPlayer", PlayerSteamName, PlayerSteamID); }
    void ServerLoadArkInventoryItems(TArray<FItemNetInfo>* ArkInventoryItems, bool bFinalBatch) { NativeCall<void, TArray<FItemNetInfo>*, bool>(this, "AShooterPlayerController.ServerLoadArkInventoryItems", ArkInventoryItems, bFinalBatch); }
    void ServerLoadUploadedCharacters() { NativeCall<void>(this, "AShooterPlayerController.ServerLoadUploadedCharacters"); }
    void ServerLoadUploadedDinos() { NativeCall<void>(this, "AShooterPlayerController.ServerLoadUploadedDinos"); }
    void ServerLoginToVivox() { NativeCall<void>(this, "AShooterPlayerController.ServerLoginToVivox"); }
    void ServerMultiUse(UObject* ForObject, int useIndex) { NativeCall<void, UObject*, int>(this, "AShooterPlayerController.ServerMultiUse", ForObject, useIndex); }
    void ServerNotifyEditText(FString* TextToUse, bool checkedBox, TSubclassOf<UObject> ForObjectClass, unsigned int ExtraID1, unsigned int ExtraID2, UObject* ForObject) { NativeCall<void, FString*, bool, TSubclassOf<UObject>, unsigned int, unsigned int, UObject*>(this, "AShooterPlayerController.ServerNotifyEditText", TextToUse, checkedBox, ForObjectClass, ExtraID1, ExtraID2, ForObject); }
    void ServerPaint(UStructurePaintingComponent* Structure, TArray<FPaintItem>* Paints, bool bLastBatch, bool bFromLoadFile) { NativeCall<void, UStructurePaintingComponent*, TArray<FPaintItem>*, bool, bool>(this, "AShooterPlayerController.ServerPaint", Structure, Paints, bLastBatch, bFromLoadFile); }
    void ServerReadMessageOFTheDay() { NativeCall<void>(this, "AShooterPlayerController.ServerReadMessageOFTheDay"); }
    void ServerRecieveSpectatorLocationAndRotation(FVector spectatorLocation, FRotator spectatorRotation) { NativeCall<void, FVector, FRotator>(this, "AShooterPlayerController.ServerRecieveSpectatorLocationAndRotation", spectatorLocation, spectatorRotation); }
    void ServerRefreshSteamInventory() { NativeCall<void>(this, "AShooterPlayerController.ServerRefreshSteamInventory"); }
    void ServerReleaseSeatingStructure() { NativeCall<void>(this, "AShooterPlayerController.ServerReleaseSeatingStructure"); }
    void ServerRemovePassenger() { NativeCall<void>(this, "AShooterPlayerController.ServerRemovePassenger"); }
    void ServerRemovePawnItem(FItemNetID itemID, bool bSecondryAction) { NativeCall<void, FItemNetID, bool>(this, "AShooterPlayerController.ServerRemovePawnItem", itemID, bSecondryAction); }
    void ServerRemoveSteamItemSucceeded() { NativeCall<void>(this, "AShooterPlayerController.ServerRemoveSteamItemSucceeded"); }
    void ServerRepairItem(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRepairItem", inventoryComp, itemID); }
    void ServerRepeatMultiUse(UObject* ForObject, int useIndex) { NativeCall<void, UObject*, int>(this, "AShooterPlayerController.ServerRepeatMultiUse", ForObject, useIndex); }
    void ServerRequestActorItems(UPrimalInventoryComponent* forInventory, bool bInventoryItems, bool bIsFirstSpawn) { NativeCall<void, UPrimalInventoryComponent*, bool, bool>(this, "AShooterPlayerController.ServerRequestActorItems", forInventory, bInventoryItems, bIsFirstSpawn); }
    void ServerRequestCreateMissionDataBuff() { NativeCall<void>(this, "AShooterPlayerController.ServerRequestCreateMissionDataBuff"); }
    void ServerRequestDinoAncestors(APrimalDinoCharacter* ForDino) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterPlayerController.ServerRequestDinoAncestors", ForDino); }
    void ServerRequestDownloadDino(FARKTributeDino DownloadedDino) { NativeCall<void, FARKTributeDino>(this, "AShooterPlayerController.ServerRequestDownloadDino", DownloadedDino); }
    void ServerRequestDownloadPlayerCharacter(FArkTributePlayerData DownloadedCharacter, int spawnPointID, int spawnRegionIndex) { NativeCall<void, FArkTributePlayerData, int, int>(this, "AShooterPlayerController.ServerRequestDownloadPlayerCharacter", DownloadedCharacter, spawnPointID, spawnRegionIndex); }
    void ServerRequestDropAllItems(FString* CurrentCustomFolderFilter, FString* CurrentNameFilter) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ServerRequestDropAllItems", CurrentCustomFolderFilter, CurrentNameFilter); }
    void ServerRequestFastTravelToPoint(int fromSpawnPointID, int spawnPointID) { NativeCall<void, int, int>(this, "AShooterPlayerController.ServerRequestFastTravelToPoint", fromSpawnPointID, spawnPointID); }
    void ServerRequestInventorySwapItems(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID1, FItemNetID itemID2) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, FItemNetID>(this, "AShooterPlayerController.ServerRequestInventorySwapItems", inventoryComp, itemID1, itemID2); }
    void ServerRequestInventoryUseItem(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestInventoryUseItem", inventoryComp, itemID); }
    void ServerRequestInventoryUseItemWithActor(AActor* anActor, UPrimalInventoryComponent* inventoryComp, FItemNetID itemID1, int AdditionalData) { NativeCall<void, AActor*, UPrimalInventoryComponent*, FItemNetID, int>(this, "AShooterPlayerController.ServerRequestInventoryUseItemWithActor", anActor, inventoryComp, itemID1, AdditionalData); }
    void ServerRequestInventoryUseItemWithItem(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID1, FItemNetID itemID2, int AdditionalData) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, FItemNetID, int>(this, "AShooterPlayerController.ServerRequestInventoryUseItemWithItem", inventoryComp, itemID1, itemID2, AdditionalData); }
    void ServerRequestLevelUp(UPrimalCharacterStatusComponent* forStatusComp, EPrimalCharacterStatusValue::Type ValueType) { NativeCall<void, UPrimalCharacterStatusComponent*, EPrimalCharacterStatusValue::Type>(this, "AShooterPlayerController.ServerRequestLevelUp", forStatusComp, ValueType); }
    void ServerRequestMyTribeOnlineList() { NativeCall<void>(this, "AShooterPlayerController.ServerRequestMyTribeOnlineList"); }
    void ServerRequestPlaceStructure(int StructureIndex, FVector BuildLocation, FRotator BuildRotation, FRotator PlayerViewRotation, APawn* AttachToPawn, APrimalDinoCharacter* DinoCharacter, FName BoneName, FItemNetID PlaceUsingItemID, bool bSnapped, bool bIsCheat, bool bIsFlipped, int SnapPointCycle) { NativeCall<void, int, FVector, FRotator, FRotator, APawn*, APrimalDinoCharacter*, FName, FItemNetID, bool, bool, bool, int>(this, "AShooterPlayerController.ServerRequestPlaceStructure", StructureIndex, BuildLocation, BuildRotation, PlayerViewRotation, AttachToPawn, DinoCharacter, BoneName, PlaceUsingItemID, bSnapped, bIsCheat, bIsFlipped, SnapPointCycle); }
    void ServerRequestRemoteDropAllItems(UPrimalInventoryComponent* inventoryComp, FString* CurrentCustomFolderFilter, FString* CurrentNameFilter) { NativeCall<void, UPrimalInventoryComponent*, FString*, FString*>(this, "AShooterPlayerController.ServerRequestRemoteDropAllItems", inventoryComp, CurrentCustomFolderFilter, CurrentNameFilter); }
    void ServerRequestRemoveItemSkin(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestRemoveItemSkin", inventoryComp, itemID); }
    void ServerRequestRemoveItemSkinOnly(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestRemoveItemSkinOnly", inventoryComp, itemID); }
    void ServerRequestRemoveWeaponAccessoryOnly(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestRemoveWeaponAccessoryOnly", inventoryComp, itemID); }
    void ServerRequestRemoveWeaponClipAmmo(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestRemoveWeaponClipAmmo", inventoryComp, itemID); }
    void ServerRequestRespawnAtPoint(int spawnPointID, int spawnRegionIndex) { NativeCall<void, int, int>(this, "AShooterPlayerController.ServerRequestRespawnAtPoint", spawnPointID, spawnRegionIndex); }
    void ServerRequestSetPin(UObject* forTarget, int PinValue, bool bIsSetting, int TheCustomIndex) { NativeCall<void, UObject*, int, bool, int>(this, "AShooterPlayerController.ServerRequestSetPin", forTarget, PinValue, bIsSetting, TheCustomIndex); }
    void ServerRequestShowLeaderboards(TSubclassOf<ULeaderboard> LeaderboardType, FName MissionTag) { NativeCall<void, TSubclassOf<ULeaderboard>, FName>(this, "AShooterPlayerController.ServerRequestShowLeaderboards", LeaderboardType, MissionTag); }
    void ServerRequestTribeLog() { NativeCall<void>(this, "AShooterPlayerController.ServerRequestTribeLog"); }
    void ServerSendArkDataPayload(FGuid ID, EPrimalARKTributeDataType::Type ArkDataType, TArray<unsigned char>* DataBytes) { NativeCall<void, FGuid, EPrimalARKTributeDataType::Type, TArray<unsigned char>*>(this, "AShooterPlayerController.ServerSendArkDataPayload", ID, ArkDataType, DataBytes); }
    void ServerSendArkDataPayloadBegin(FGuid ID, EPrimalARKTributeDataType::Type ArkDataType, FString* DataClass, FString* TagName, FString* Name, TArray<FString>* DataStats, unsigned int ID1, unsigned int ID2) { NativeCall<void, FGuid, EPrimalARKTributeDataType::Type, FString*, FString*, FString*, TArray<FString>*, unsigned int, unsigned int>(this, "AShooterPlayerController.ServerSendArkDataPayloadBegin", ID, ArkDataType, DataClass, TagName, Name, DataStats, ID1, ID2); }
    void ServerSendArkDataPayloadEnd(FGuid ID, EPrimalARKTributeDataType::Type ArkDataType) { NativeCall<void, FGuid, EPrimalARKTributeDataType::Type>(this, "AShooterPlayerController.ServerSendArkDataPayloadEnd", ID, ArkDataType); }
    void ServerSendChatMessage(FString* ChatMessage, EChatSendMode::Type SendMode) { NativeCall<void, FString*, EChatSendMode::Type>(this, "AShooterPlayerController.ServerSendChatMessage", ChatMessage, SendMode); }
    void ServerSendDirectMessage(FString* PlayerSteamID, FString* Message) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ServerSendDirectMessage", PlayerSteamID, Message); }
    void ServerSetSubscribedApp(int AppID, bool bPreventDefaultItems) { NativeCall<void, int, bool>(this, "AShooterPlayerController.ServerSetSubscribedApp", AppID, bPreventDefaultItems); }
    void ServerSetSupressAdminIcon(bool bSuppress) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerSetSupressAdminIcon", bSuppress); }
    void ServerSetVRPlayer(bool bSetVRPlayer) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerSetVRPlayer", bSetVRPlayer); }
    void ServerSpectateToPlayerByID(unsigned __int64 PlayerID) { NativeCall<void, unsigned __int64>(this, "AShooterPlayerController.ServerSpectateToPlayerByID", PlayerID); }
    void ServerStartWeaponAltFire(AShooterWeapon* weapon) { NativeCall<void, AShooterWeapon*>(this, "AShooterPlayerController.ServerStartWeaponAltFire", weapon); }
    void ServerStartWeaponFire(AShooterWeapon* weapon) { NativeCall<void, AShooterWeapon*>(this, "AShooterPlayerController.ServerStartWeaponFire", weapon); }
    void ServerStayAlive() { NativeCall<void>(this, "AShooterPlayerController.ServerStayAlive"); }
    void ServerStopSpectating() { NativeCall<void>(this, "AShooterPlayerController.ServerStopSpectating"); }
    void ServerStopWeaponAltFire(AShooterWeapon* weapon) { NativeCall<void, AShooterWeapon*>(this, "AShooterPlayerController.ServerStopWeaponAltFire", weapon); }
    void ServerStopWeaponFire(AShooterWeapon* weapon) { NativeCall<void, AShooterWeapon*>(this, "AShooterPlayerController.ServerStopWeaponFire", weapon); }
    void ServerSuccessfullyLoggedIntoVivox(FString* LoginSessionUserUri) { NativeCall<void, FString*>(this, "AShooterPlayerController.ServerSuccessfullyLoggedIntoVivox", LoginSessionUserUri); }
    void ServerTransferAllFromRemoteInventory(UPrimalInventoryComponent* inventoryComp, FString* CurrentCustomFolderFilter, FString* CurrentNameFilter, FString* CurrentDestinationFolder, bool bNoFolderView) { NativeCall<void, UPrimalInventoryComponent*, FString*, FString*, FString*, bool>(this, "AShooterPlayerController.ServerTransferAllFromRemoteInventory", inventoryComp, CurrentCustomFolderFilter, CurrentNameFilter, CurrentDestinationFolder, bNoFolderView); }
    void ServerTransferAllToRemoteInventory(UPrimalInventoryComponent* inventoryComp, FString* CurrentCustomFolderFilter, FString* CurrentNameFilter, FString* CurrentDestinationFolder, bool bNoFolderView) { NativeCall<void, UPrimalInventoryComponent*, FString*, FString*, FString*, bool>(this, "AShooterPlayerController.ServerTransferAllToRemoteInventory", inventoryComp, CurrentCustomFolderFilter, CurrentNameFilter, CurrentDestinationFolder, bNoFolderView); }
    void ServerTransferFromRemoteInventory(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, int requestedQuantity, int ToSlotIndex, bool bEquipItem) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, int, int, bool>(this, "AShooterPlayerController.ServerTransferFromRemoteInventory", inventoryComp, itemID, requestedQuantity, ToSlotIndex, bEquipItem); }
    void ServerTransferredPlayerConfirmationResult(bool bAccept) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerTransferredPlayerConfirmationResult", bAccept); }
    void ServerTransferToRemoteInventory(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, bool bAlsoTryToEqup, int requestedQuantity) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, bool, int>(this, "AShooterPlayerController.ServerTransferToRemoteInventory", inventoryComp, itemID, bAlsoTryToEqup, requestedQuantity); }
    void ServerUnbanPlayer(FString* PlayerSteamName, FString* PlayerSteamID) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ServerUnbanPlayer", PlayerSteamName, PlayerSteamID); }
    void ServerUnlockPerMapExplorerNote(int ExplorerNoteIndex) { NativeCall<void, int>(this, "AShooterPlayerController.ServerUnlockPerMapExplorerNote", ExplorerNoteIndex); }
    void ServerUploadCharaterDataToArk(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerUploadCharaterDataToArk", inventoryComp); }
    void ServerUploadCurrentCharacterAndItems(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerUploadCurrentCharacterAndItems", inventoryComp); }
    void ServerUploadDino(APrimalDinoCharacter* DownloadedDino) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterPlayerController.ServerUploadDino", DownloadedDino); }
 
    // Enums
 
    enum CharacterTransferState
    {
        CTS_None = 0x0,
        CTS_Transferring = 0x1,
        CTS_Downloading = 0x2,
        CTS_Done = 0x3,
    };
};
 
struct ACharacter : APawn
{
    TSubobjectPtr<UCharacterMovementComponent>& CharacterMovementField() { return *GetNativePointerField<TSubobjectPtr<UCharacterMovementComponent>*>(this, "ACharacter.CharacterMovement"); }
    FVector& BaseTranslationOffsetField() { return *GetNativePointerField<FVector*>(this, "ACharacter.BaseTranslationOffset"); }
    char& ReplicatedMovementModeField() { return *GetNativePointerField<char*>(this, "ACharacter.ReplicatedMovementMode"); }
    float& LeftDynamicActorBaseTimeField() { return *GetNativePointerField<float*>(this, "ACharacter.LeftDynamicActorBaseTime"); }
    float& CrouchedEyeHeightField() { return *GetNativePointerField<float*>(this, "ACharacter.CrouchedEyeHeight"); }
    float& ProneEyeHeightField() { return *GetNativePointerField<float*>(this, "ACharacter.ProneEyeHeight"); }
    float& HarvestingDestructionMeshRangeMultiplerField() { return *GetNativePointerField<float*>(this, "ACharacter.HarvestingDestructionMeshRangeMultipler"); }
    TArray<USoundBase*> CharacterOverrideSoundFromField() { return *GetNativePointerField<TArray<USoundBase*>*>(this, "ACharacter.CharacterOverrideSoundFrom"); }
    TArray<USoundBase*> CharacterOverrideSoundToField() { return *GetNativePointerField<TArray<USoundBase*>*>(this, "ACharacter.CharacterOverrideSoundTo"); }
    bool& bInBaseReplicationField() { return *GetNativePointerField<bool*>(this, "ACharacter.bInBaseReplication"); }
    float& JumpKeyHoldTimeField() { return *GetNativePointerField<float*>(this, "ACharacter.JumpKeyHoldTime"); }
    float& JumpMaxHoldTimeField() { return *GetNativePointerField<float*>(this, "ACharacter.JumpMaxHoldTime"); }
    float& ExtraMaxAccelerationModifierField() { return *GetNativePointerField<float*>(this, "ACharacter.ExtraMaxAccelerationModifier"); }
    float& ExtraFrictionModifierField() { return *GetNativePointerField<float*>(this, "ACharacter.ExtraFrictionModifier"); }
    int& LastTeleportedFrameField() { return *GetNativePointerField<int*>(this, "ACharacter.LastTeleportedFrame"); }
    long double& ForceUnfreezeSkeletalDynamicsUntilTimeField() { return *GetNativePointerField<long double*>(this, "ACharacter.ForceUnfreezeSkeletalDynamicsUntilTime"); }
 
    // Bit fields
 
    BitFieldValue<bool, unsigned __int32> bIsCrouched() { return { this, "ACharacter.bIsCrouched" }; }
    BitFieldValue<bool, unsigned __int32> bIsProne() { return { this, "ACharacter.bIsProne" }; }
    BitFieldValue<bool, unsigned __int32> bCanEverProne() { return { this, "ACharacter.bCanEverProne" }; }
    BitFieldValue<bool, unsigned __int32> bCanEverCrouch() { return { this, "ACharacter.bCanEverCrouch" }; }
    BitFieldValue<bool, unsigned __int32> bReplicateDesiredRotation() { return { this, "ACharacter.bReplicateDesiredRotation" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOverrideCharacterSound() { return { this, "ACharacter.bUseBPOverrideCharacterSound" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOverrideCharacterParticle() { return { this, "ACharacter.bUseBPOverrideCharacterParticle" }; }
    BitFieldValue<bool, unsigned __int32> bPressedJump() { return { this, "ACharacter.bPressedJump" }; }
    BitFieldValue<bool, unsigned __int32> bClientUpdating() { return { this, "ACharacter.bClientUpdating" }; }
    BitFieldValue<bool, unsigned __int32> bIsPlayingTurningAnim() { return { this, "ACharacter.bIsPlayingTurningAnim" }; }
    BitFieldValue<bool, unsigned __int32> bClientWasFalling() { return { this, "ACharacter.bClientWasFalling" }; }
    BitFieldValue<bool, unsigned __int32> bClientResimulateRootMotion() { return { this, "ACharacter.bClientResimulateRootMotion" }; }
    BitFieldValue<bool, unsigned __int32> bSimGravityDisabled() { return { this, "ACharacter.bSimGravityDisabled" }; }
    BitFieldValue<bool, unsigned __int32> bIsBigPusher() { return { this, "ACharacter.bIsBigPusher" }; }
    BitFieldValue<bool, unsigned __int32> bCanBePushed() { return { this, "ACharacter.bCanBePushed" }; }
    BitFieldValue<bool, unsigned __int32> bCanPushOthers() { return { this, "ACharacter.bCanPushOthers" }; }
    BitFieldValue<bool, unsigned __int32> bSetDefaultMovementMode() { return { this, "ACharacter.bSetDefaultMovementMode" }; }
    BitFieldValue<bool, unsigned __int32> bOverrideWalkingVelocity() { return { this, "ACharacter.bOverrideWalkingVelocity" }; }
    BitFieldValue<bool, unsigned __int32> bOverrideSwimmingVelocity() { return { this, "ACharacter.bOverrideSwimmingVelocity" }; }
    BitFieldValue<bool, unsigned __int32> bOverrideNewFallVelocity() { return { this, "ACharacter.bOverrideNewFallVelocity" }; }
    BitFieldValue<bool, unsigned __int32> bOverrideFlyingVelocity() { return { this, "ACharacter.bOverrideFlyingVelocity" }; }
    BitFieldValue<bool, unsigned __int32> bPreventWaterHopCorrectionVelChange() { return { this, "ACharacter.bPreventWaterHopCorrectionVelChange" }; }
    BitFieldValue<bool, unsigned __int32> bUsesRootMotion() { return { this, "ACharacter.bUsesRootMotion" }; }
    BitFieldValue<bool, unsigned __int32> bBasedUsesFastPathSMCTick() { return { this, "ACharacter.bBasedUsesFastPathSMCTick" }; }
    BitFieldValue<bool, unsigned __int32> bBasedUsesFastPathMoveTick() { return { this, "ACharacter.bBasedUsesFastPathMoveTick" }; }
    BitFieldValue<bool, unsigned __int32> bForceUnfreezeIkNextFrame() { return { this, "ACharacter.bForceUnfreezeIkNextFrame" }; }
 
    // Functions
 
    bool NotifyLanded(FHitResult* Hit) { return NativeCall<bool, FHitResult*>(this, "ACharacter.NotifyLanded", Hit); }
    bool IsJumping() { return NativeCall<bool>(this, "ACharacter.IsJumping"); }
    float ModifyAirControl(float Damage, FPointDamageEvent* PointDamageEvent, AController* EventInstigator, AActor* DamageCauser) { return NativeCall<float, float, FPointDamageEvent*, AController*, AActor*>(this, "ACharacter.ModifyAirControl", Damage, PointDamageEvent, EventInstigator, DamageCauser); }
    UPrimitiveComponent* GetMovementBase() { return NativeCall<UPrimitiveComponent*>(this, "ACharacter.GetMovementBase"); }
    void SetLastMovementDesiredRotation(FRotator* InRotation) { NativeCall<void, FRotator*>(this, "ACharacter.SetLastMovementDesiredRotation", InRotation); }
    bool AllowOverrideFlyingVelocity() { return NativeCall<bool>(this, "ACharacter.AllowOverrideFlyingVelocity"); }
    bool AllowOverrideNewFallVelocity() { return NativeCall<bool>(this, "ACharacter.AllowOverrideNewFallVelocity"); }
    bool AllowOverrideSwimmingVelocity() { return NativeCall<bool>(this, "ACharacter.AllowOverrideSwimmingVelocity"); }
    bool AllowOverrideWalkingVelocity() { return NativeCall<bool>(this, "ACharacter.AllowOverrideWalkingVelocity"); }
    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "ACharacter.GetPrivateStaticClass"); }
    FRotator* BPModifyRootMotionDeltaRotation_Implementation(FRotator* result, FRotator* Delta) { return NativeCall<FRotator*, FRotator*, FRotator*>(this, "ACharacter.BPModifyRootMotionDeltaRotation_Implementation", result, Delta); }
    void PostInitializeComponents() { NativeCall<void>(this, "ACharacter.PostInitializeComponents"); }
    void GetSimpleCollisionCylinder(float* CollisionRadius, float* CollisionHalfHeight) { NativeCall<void, float*, float*>(this, "ACharacter.GetSimpleCollisionCylinder", CollisionRadius, CollisionHalfHeight); }
    void ApplyWorldOffset(FVector* InOffset, bool bWorldShift) { NativeCall<void, FVector*, bool>(this, "ACharacter.ApplyWorldOffset", InOffset, bWorldShift); }
    float GetDefaultHalfHeight() { return NativeCall<float>(this, "ACharacter.GetDefaultHalfHeight"); }
    UActorComponent* FindComponentByClass(TSubclassOf<UActorComponent> ComponentClass) { return NativeCall<UActorComponent*, TSubclassOf<UActorComponent>>(this, "ACharacter.FindComponentByClass", ComponentClass); }
    void Landed(FHitResult* Hit) { NativeCall<void, FHitResult*>(this, "ACharacter.Landed", Hit); }
    bool CanJump() { return NativeCall<bool>(this, "ACharacter.CanJump"); }
    bool CanJumpInternal_Implementation() { return NativeCall<bool>(this, "ACharacter.CanJumpInternal_Implementation"); }
    bool DoJump(bool bReplayingMoves) { return NativeCall<bool, bool>(this, "ACharacter.DoJump", bReplayingMoves); }
    void RecalculateBaseEyeHeight() { NativeCall<void>(this, "ACharacter.RecalculateBaseEyeHeight"); }
    void OnRep_IsCrouched() { NativeCall<void>(this, "ACharacter.OnRep_IsCrouched"); }
    void OnRep_IsProne() { NativeCall<void>(this, "ACharacter.OnRep_IsProne"); }
    bool CanCrouch() { return NativeCall<bool>(this, "ACharacter.CanCrouch"); }
    void Crouch(bool bClientSimulation) { NativeCall<void, bool>(this, "ACharacter.Crouch", bClientSimulation); }
    void UnCrouch(bool bClientSimulation) { NativeCall<void, bool>(this, "ACharacter.UnCrouch", bClientSimulation); }
    bool CanProne() { return NativeCall<bool>(this, "ACharacter.CanProne"); }
    void Prone(bool bClientSimulation) { NativeCall<void, bool>(this, "ACharacter.Prone", bClientSimulation); }
    void UnProne(bool bClientSimulation) { NativeCall<void, bool>(this, "ACharacter.UnProne", bClientSimulation); }
    void OnEndCrouch(float HeightAdjust, float ScaledHeightAdjust) { NativeCall<void, float, float>(this, "ACharacter.OnEndCrouch", HeightAdjust, ScaledHeightAdjust); }
    void OnStartCrouch(float HeightAdjust, float ScaledHeightAdjust) { NativeCall<void, float, float>(this, "ACharacter.OnStartCrouch", HeightAdjust, ScaledHeightAdjust); }
    void ApplyDamageMomentum(float DamageTaken, FDamageEvent* DamageEvent, APawn* PawnInstigator, AActor* DamageCauser) { NativeCall<void, float, FDamageEvent*, APawn*, AActor*>(this, "ACharacter.ApplyDamageMomentum", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }
    void TeleportSucceeded(bool bIsATest, bool bSimpleTeleport) { NativeCall<void, bool, bool>(this, "ACharacter.TeleportSucceeded", bIsATest, bSimpleTeleport); }
    void NetTeleportSucceeded_Implementation(FVector ToLoc, FRotator ToRot) { NativeCall<void, FVector, FRotator>(this, "ACharacter.NetTeleportSucceeded_Implementation", ToLoc, ToRot); }
    void ClearCrossLevelReferences() { NativeCall<void>(this, "ACharacter.ClearCrossLevelReferences"); }
    void SetBase(UPrimitiveComponent* NewBaseComponent, FName BoneName, bool bNotifyPawn) { NativeCall<void, UPrimitiveComponent*, FName, bool>(this, "ACharacter.SetBase", NewBaseComponent, BoneName, bNotifyPawn); }
    bool IsBasedOnDynamicActor() { return NativeCall<bool>(this, "ACharacter.IsBasedOnDynamicActor"); }
    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", NewController); }
    void UnPossessed() { NativeCall<void>(this, "ACharacter.UnPossessed"); }
    void TornOff() { NativeCall<void>(this, "ACharacter.TornOff"); }
    void BaseChange() { NativeCall<void>(this, "ACharacter.BaseChange"); }
    void LaunchCharacter(FVector LaunchVelocity, bool bXYOverride, bool bZOverride) { NativeCall<void, FVector, bool, bool>(this, "ACharacter.LaunchCharacter", LaunchVelocity, bXYOverride, bZOverride); }
    void OnMovementModeChanged(EMovementMode PrevMovementMode, char PrevCustomMode) { NativeCall<void, EMovementMode, char>(this, "ACharacter.OnMovementModeChanged", PrevMovementMode, PrevCustomMode); }
    bool ShouldNotifyLanded(FHitResult* Hit) { return NativeCall<bool, FHitResult*>(this, "ACharacter.ShouldNotifyLanded", 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", DeltaTime); }
    void ClearJumpInput() { NativeCall<void>(this, "ACharacter.ClearJumpInput"); }
    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 OnRep_RootMotion() { NativeCall<void>(this, "ACharacter.OnRep_RootMotion"); }
    void UpdateSimulatedPosition(FVector* NewLocation, FRotator* NewRotation) { NativeCall<void, FVector*, FRotator*>(this, "ACharacter.UpdateSimulatedPosition", NewLocation, NewRotation); }
    void PostNetReceiveLocationAndRotation() { NativeCall<void>(this, "ACharacter.PostNetReceiveLocationAndRotation"); }
    bool TeleportTo(FVector* DestLocation, FRotator* DestRotation, bool bIsATest, bool bNoCheck) { return NativeCall<bool, FVector*, FRotator*, bool, bool>(this, "ACharacter.TeleportTo", DestLocation, DestRotation, bIsATest, bNoCheck); }
    bool SimpleTeleportTo(FVector* DestLocation, FRotator* DestRotation) { return NativeCall<bool, FVector*, FRotator*>(this, "ACharacter.SimpleTeleportTo", DestLocation, DestRotation); }
    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "ACharacter.GetLifetimeReplicatedProps", OutLifetimeProps); }
    bool IsPlayingRootMotion() { return NativeCall<bool>(this, "ACharacter.IsPlayingRootMotion"); }
    USoundBase* BPOverrideCharacterSound_Implementation(USoundBase* SoundIn) { return NativeCall<USoundBase*, USoundBase*>(this, "ACharacter.BPOverrideCharacterSound_Implementation", SoundIn); }
    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", AnimMontage, InPlayRate, StartSectionName, bForceTickPoseAndServerUpdateMesh, bForceTickPoseOnServer, BlendInTime, BlendOutTime); }
    void StopAnimMontage(UAnimMontage* AnimMontage) { NativeCall<void, UAnimMontage*>(this, "ACharacter.StopAnimMontage", 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 ShouldReplicateRotPitch() { return NativeCall<bool>(this, "ACharacter.ShouldReplicateRotPitch"); }
    float OverrideTerminalVelocity(bool bIgnoreTrueBlack, bool bUseGrayscale) { return NativeCall<float, bool, bool>(this, "ACharacter.OverrideTerminalVelocity", bIgnoreTrueBlack, bUseGrayscale); }
    static void StaticRegisterNativesACharacter() { NativeCall<void>(nullptr, "ACharacter.StaticRegisterNativesACharacter"); }
    bool BP_PreventMovementMode(EMovementMode newMovementMode, char newCustomMode) { return NativeCall<bool, EMovementMode, char>(this, "ACharacter.BP_PreventMovementMode", newMovementMode, newCustomMode); }
    FRotator* BPModifyRootMotionDeltaRotation(FRotator* result, FRotator* Delta) { return NativeCall<FRotator*, FRotator*, FRotator*>(this, "ACharacter.BPModifyRootMotionDeltaRotation", result, Delta); }
    void K2_OnEndCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust) { NativeCall<void, float, float>(this, "ACharacter.K2_OnEndCrouch", HalfHeightAdjust, ScaledHalfHeightAdjust); }
    void K2_OnMovementModeChanged(EMovementMode PrevMovementMode, EMovementMode NewMovementMode, char PrevCustomMode, char NewCustomMode) { NativeCall<void, EMovementMode, EMovementMode, char, char>(this, "ACharacter.K2_OnMovementModeChanged", PrevMovementMode, NewMovementMode, PrevCustomMode, NewCustomMode); }
    void K2_OnStartCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust) { NativeCall<void, float, float>(this, "ACharacter.K2_OnStartCrouch", HalfHeightAdjust, ScaledHalfHeightAdjust); }
    void K2_UpdateCustomMovement(float DeltaTime) { NativeCall<void, float>(this, "ACharacter.K2_UpdateCustomMovement", DeltaTime); }
    void OnJumped() { NativeCall<void>(this, "ACharacter.OnJumped"); }
    void OnLanded(FHitResult* Hit) { NativeCall<void, FHitResult*>(this, "ACharacter.OnLanded", Hit); }
    void OnLaunched(FVector LaunchVelocity, bool bXYOverride, bool bZOverride) { NativeCall<void, FVector, bool, bool>(this, "ACharacter.OnLaunched", LaunchVelocity, bXYOverride, bZOverride); }
    void OnWalkingOffLedge() { NativeCall<void>(this, "ACharacter.OnWalkingOffLedge"); }
    bool ReplicateMovementToSimulatedClients() { return NativeCall<bool>(this, "ACharacter.ReplicateMovementToSimulatedClients"); }
};
 
struct APrimalCharacter : ACharacter
{
    FVector & OldLocationField() { return *GetNativePointerField<FVector*>(this, "APrimalCharacter.OldLocation"); }
    FRotator & OldRotationField() { return *GetNativePointerField<FRotator*>(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"); }
    FVector & GroundCheckExtentField() { return *GetNativePointerField<FVector*>(this, "APrimalCharacter.GroundCheckExtent"); }
    long double& LastForceAimedCharactersTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastForceAimedCharactersTime"); }
    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 * PinnedAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalCharacter.PinnedAnim"); }
    USoundCue * HurtSoundField() { return *GetNativePointerField<USoundCue**>(this, "APrimalCharacter.HurtSound"); }
    FName & RootBodyBoneNameField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.RootBodyBoneName"); }
    TArray<APrimalBuff*> BuffsField() { return *GetNativePointerField<TArray<APrimalBuff*>*>(this, "APrimalCharacter.Buffs"); }
    long double& LastStartedTalkingTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastStartedTalkingTime"); }
    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> & SubmergedWaterMovementModeField() { return *GetNativePointerField<TEnumAsByte<enum EMovementMode>*>(this, "APrimalCharacter.SubmergedWaterMovementMode"); }
    TEnumAsByte<enum EMovementMode> & UnSubmergedWaterMovementModeField() { return *GetNativePointerField<TEnumAsByte<enum EMovementMode>*>(this, "APrimalCharacter.UnSubmergedWaterMovementMode"); }
    float& SnapshotScaleField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.SnapshotScale"); }
    TArray<FPrimalSnapshotPose> & SnapshotPosesField() { return *GetNativePointerField<TArray<FPrimalSnapshotPose>*>(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> & BonesToIngoreWhileDraggedField() { return *GetNativePointerField<TArray<FName>*>(this, "APrimalCharacter.BonesToIngoreWhileDragged"); }
    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"); }
    FTransform & LocalDraggedCharacterTransformField() { return *GetNativePointerField<FTransform*>(this, "APrimalCharacter.LocalDraggedCharacterTransform"); }
    long double& StartDraggingTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.StartDraggingTime"); }
    long double& LastDragUpdateTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastDragUpdateTime"); }
    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"); }
    TArray<TSubclassOf<APrimalStructure>> & ImmobilizationTrapsToIgnoreField() { return *GetNativePointerField<TArray<TSubclassOf<APrimalStructure>>*>(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"); }
    AShooterCharacter * LastGrapHookPullingOwnerField() { return *GetNativePointerField<AShooterCharacter**>(this, "APrimalCharacter.LastGrapHookPullingOwner"); }
    AActor*& LastGrapHookPullingMeField() { return *GetNativePointerField<AActor**>(this, "APrimalCharacter.LastGrapHookPullingMe"); }
    FVector & DragOffsetField() { return *GetNativePointerField<FVector*>(this, "APrimalCharacter.DragOffset"); }
    long double& LastIkUpdateTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastIkUpdateTime"); }
    long double& LastUpdatedAimOffsetsTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastUpdatedAimOffsetsTime"); }
    FVector & MeshPreRagdollRelativeLocationField() { return *GetNativePointerField<FVector*>(this, "APrimalCharacter.MeshPreRagdollRelativeLocation"); }
    FRotator & MeshPreRagdollRelativeRotationField() { return *GetNativePointerField<FRotator*>(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"); }
    USoundCue * DeathSoundField() { return *GetNativePointerField<USoundCue**>(this, "APrimalCharacter.DeathSound"); }
    USoundCue * RunLoopSoundField() { return *GetNativePointerField<USoundCue**>(this, "APrimalCharacter.RunLoopSound"); }
    USoundCue * RunStopSoundField() { return *GetNativePointerField<USoundCue**>(this, "APrimalCharacter.RunStopSound"); }
    TArray<USoundCue*> FootStepSoundsPhysMatField() { return *GetNativePointerField<TArray<USoundCue*>*>(this, "APrimalCharacter.FootStepSoundsPhysMat"); }
    TArray<USoundCue*> LandedSoundsPhysMatField() { return *GetNativePointerField<TArray<USoundCue*>*>(this, "APrimalCharacter.LandedSoundsPhysMat"); }
    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"); }
    float& CurrentCarriedYawField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.CurrentCarriedYaw"); }
    APrimalStructureExplosiveTransGPS * CurrentTransponderField() { return *GetNativePointerField<APrimalStructureExplosiveTransGPS**>(this, "APrimalCharacter.CurrentTransponder"); }
    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"); }
    float& MountedDinoTimeField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.MountedDinoTime"); }
    TWeakObjectPtr<APrimalDinoCharacter> & PreviousMountedDinoField() { return *GetNativePointerField<TWeakObjectPtr<APrimalDinoCharacter>*>(this, "APrimalCharacter.PreviousMountedDino"); }
    FVector & LastForceFallCheckBaseLocationField() { return *GetNativePointerField<FVector*>(this, "APrimalCharacter.LastForceFallCheckBaseLocation"); }
    FVector & LastHitWallSweepCheckLocationField() { return *GetNativePointerField<FVector*>(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"); }
    FString & DescriptiveNameField() { return *GetNativePointerField<FString*>(this, "APrimalCharacter.DescriptiveName"); }
    TArray<FVector_NetQuantize> & ReplicatedRagdollPositionsField() { return *GetNativePointerField<TArray<FVector_NetQuantize>*>(this, "APrimalCharacter.ReplicatedRagdollPositions"); }
    TArray<FRotator_NetQuantize> & ReplicatedRagdollRotationsField() { return *GetNativePointerField<TArray<FRotator_NetQuantize>*>(this, "APrimalCharacter.ReplicatedRagdollRotations"); }
    TArray<FVector_NetQuantize> & LastReplicatedRagdollPositionsField() { return *GetNativePointerField<TArray<FVector_NetQuantize>*>(this, "APrimalCharacter.LastReplicatedRagdollPositions"); }
    TArray<FRotator_NetQuantize> & LastReplicatedRagdollRotationsField() { return *GetNativePointerField<TArray<FRotator_NetQuantize>*>(this, "APrimalCharacter.LastReplicatedRagdollRotations"); }
    FRotator & ReplicatedRootRotationField() { return *GetNativePointerField<FRotator*>(this, "APrimalCharacter.ReplicatedRootRotation"); }
    TArray<int> & ReplicatedBonesIndiciesField() { return *GetNativePointerField<TArray<int>*>(this, "APrimalCharacter.ReplicatedBonesIndicies"); }
    float& KillXPBaseField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.KillXPBase"); }
    TArray<FName> & ReplicatedBonesField() { return *GetNativePointerField<TArray<FName>*>(this, "APrimalCharacter.ReplicatedBones"); }
    float& RagdollReplicationIntervalField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.RagdollReplicationInterval"); }
    TArray<FBoneDamageAdjuster> & BoneDamageAdjustersField() { return *GetNativePointerField<TArray<FBoneDamageAdjuster>*>(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"); }
    FRotator & CurrentAimRotField() { return *GetNativePointerField<FRotator*>(this, "APrimalCharacter.CurrentAimRot"); }
    FVector & CurrentRootLocField() { return *GetNativePointerField<FVector*>(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"); }
    FVector & TPVCameraOffsetField() { return *GetNativePointerField<FVector*>(this, "APrimalCharacter.TPVCameraOffset"); }
    FVector & TPVCameraOffsetMultiplierField() { return *GetNativePointerField<FVector*>(this, "APrimalCharacter.TPVCameraOffsetMultiplier"); }
    FVector & TPVCameraOrgOffsetField() { return *GetNativePointerField<FVector*>(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<UAnimMontage*> AnimationsPreventInputField() { return *GetNativePointerField<TArray<UAnimMontage*>*>(this, "APrimalCharacter.AnimationsPreventInput"); }
    TSubclassOf<UPrimalHarvestingComponent> & DeathHarvestingComponentField() { return *GetNativePointerField<TSubclassOf<UPrimalHarvestingComponent>*>(this, "APrimalCharacter.DeathHarvestingComponent"); }
    UPrimalHarvestingComponent * MyDeathHarvestingComponentField() { return *GetNativePointerField<UPrimalHarvestingComponent**>(this, "APrimalCharacter.MyDeathHarvestingComponent"); }
    long double& LastNetDidLandField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastNetDidLand"); }
    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"); }
    TEnumAsByte<enum EShooterPhysMaterialType::Type> & TargetableDamageFXDefaultPhysMaterialField() { return *GetNativePointerField<TEnumAsByte<enum EShooterPhysMaterialType::Type>*>(this, "APrimalCharacter.TargetableDamageFXDefaultPhysMaterial"); }
    UAnimMontage * PoopAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalCharacter.PoopAnimation"); }
    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"); }
    USoundCue * PoopSoundField() { return *GetNativePointerField<USoundCue**>(this, "APrimalCharacter.PoopSound"); }
    float& BaseTargetingDesirabilityField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.BaseTargetingDesirability"); }
    float& DeadBaseTargetingDesirabilityField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.DeadBaseTargetingDesirability"); }
    FRotator & OrbitCamRotField() { return *GetNativePointerField<FRotator*>(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"); }
    FVector & LastSubmergedCheckLocField() { return *GetNativePointerField<FVector*>(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"); }
    FVector & DeathActorTargetingOffsetField() { return *GetNativePointerField<FVector*>(this, "APrimalCharacter.DeathActorTargetingOffset"); }
    FName & SocketOverrideTargetingLocationField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.SocketOverrideTargetingLocation"); }
    FDamageEvent * CurrentDamageEventField() { return *GetNativePointerField<FDamageEvent**>(this, "APrimalCharacter.CurrentDamageEvent"); }
    FVector & LastApproximatePhysVolumeLocationField() { return *GetNativePointerField<FVector*>(this, "APrimalCharacter.LastApproximatePhysVolumeLocation"); }
    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"); }
    float& LastHurtByNearbyPlayerTimeField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.LastHurtByNearbyPlayerTime"); }
    TWeakObjectPtr<APrimalCharacter> & LastAttackedNearbyPlayerField() { return *GetNativePointerField<TWeakObjectPtr<APrimalCharacter>*>(this, "APrimalCharacter.LastAttackedNearbyPlayer"); }
    float& LastAttackedNearbyPlayerTimeField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.LastAttackedNearbyPlayerTime"); }
    long double& LastStartFallingRagdollTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastStartFallingRagdollTime"); }
    FVector & RagdollLastFrameLinearVelocityField() { return *GetNativePointerField<FVector*>(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"); }
    FVector & PreviousRagdollLocationField() { return *GetNativePointerField<FVector*>(this, "APrimalCharacter.PreviousRagdollLocation"); }
    int& RagdollPenetrationFailuresField() { return *GetNativePointerField<int*>(this, "APrimalCharacter.RagdollPenetrationFailures"); }
    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"); }
    USoundCue * EnteredSwimmingSoundField() { return *GetNativePointerField<USoundCue**>(this, "APrimalCharacter.EnteredSwimmingSound"); }
    USoundCue * EnteredSleepingSoundField() { return *GetNativePointerField<USoundCue**>(this, "APrimalCharacter.EnteredSleepingSound"); }
    USoundCue * LeftSleepingSoundField() { return *GetNativePointerField<USoundCue**>(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"); }
    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<TSubclassOf<APrimalBuff>> & DefaultBuffsField() { return *GetNativePointerField<TArray<TSubclassOf<APrimalBuff>>*>(this, "APrimalCharacter.DefaultBuffs"); }
    UTexture2D * PoopIconField() { return *GetNativePointerField<UTexture2D**>(this, "APrimalCharacter.PoopIcon"); }
    float& RunningMaxDesiredRotDeltaField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.RunningMaxDesiredRotDelta"); }
    long double& CorpseDestructionTimerField() { return *GetNativePointerField<long double*>(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"); }
    FVector & CurrentLocalRootLocField() { return *GetNativePointerField<FVector*>(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"); }
    float& LastDamageAmountMaterialValueField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.LastDamageAmountMaterialValue"); }
    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"); }
    FVector & TargetPathfindingLocationOffsetField() { return *GetNativePointerField<FVector*>(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>> & CharactersGrappledToMeField() { return *GetNativePointerField<TArray<TWeakObjectPtr<APrimalCharacter>>*>(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"); }
    char& TribeGroupInventoryRankField() { return *GetNativePointerField<char*>(this, "APrimalCharacter.TribeGroupInventoryRank"); }
    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"); }
    float& ClientRotationInterpSpeedMultiplierGroundField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ClientRotationInterpSpeedMultiplierGround"); }
    float& GlideGravityScaleMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.GlideGravityScaleMultiplier"); }
    float& GlideMaxCarriedWeightField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.GlideMaxCarriedWeight"); }
    UAnimMontage * lastPlayedMountAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalCharacter.lastPlayedMountAnim"); }
    float& ScaleDeathHarvestHealthyByMaxHealthBaseField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ScaleDeathHarvestHealthyByMaxHealthBase"); }
    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"); }
    char& bShouldBeInGodModeField() { return *GetNativePointerField<char*>(this, "APrimalCharacter.bShouldBeInGodMode"); }
    int& MeshedCounterField() { return *GetNativePointerField<int*>(this, "APrimalCharacter.MeshedCounter"); }
    int& MeshingTickCounterMultiplierField() { return *GetNativePointerField<int*>(this, "APrimalCharacter.MeshingTickCounterMultiplier"); }
    TArray<TSubclassOf<APrimalBuff>> & PreventBuffClassesField() { return *GetNativePointerField<TArray<TSubclassOf<APrimalBuff>>*>(this, "APrimalCharacter.PreventBuffClasses"); }
 
    // Bit fields
 
    BitFieldValue<bool, unsigned __int32> bUseBlueprintJumpInputEvents() { return { this, "APrimalCharacter.bUseBlueprintJumpInputEvents" }; }
    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> 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> bDeathKeepCapsuleCollision() { return { this, "APrimalCharacter.bDeathKeepCapsuleCollision" }; }
    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> 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> 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> 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> 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> 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" }; }
 
    // Functions
 
    static UClass * StaticClass() { return NativeCall<UClass*>(nullptr, "APrimalCharacter.StaticClass"); }
    UObject * GetUObjectInterfaceTargetableInterface() { return NativeCall<UObject*>(this, "APrimalCharacter.GetUObjectInterfaceTargetableInterface"); }
    long double GetLastStartedTalkingTime() { return NativeCall<long double>(this, "APrimalCharacter.GetLastStartedTalkingTime"); }
    float GetStasisConsumerRangeMultiplier() { return NativeCall<float>(this, "APrimalCharacter.GetStasisConsumerRangeMultiplier"); }
    float BPGetAddForwardVelocityOnJump_Implementation() { return NativeCall<float>(this, "APrimalCharacter.BPGetAddForwardVelocityOnJump_Implementation"); }
    bool CanJumpInternal_Implementation() { return NativeCall<bool>(this, "APrimalCharacter.CanJumpInternal_Implementation"); }
    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(UDamageType * dmgType) { NativeCall<void, UDamageType*>(this, "APrimalCharacter.FellOutOfWorld", 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", InventoryItemObject); }
    void AdjustDamage(float* Damage, FDamageEvent * DamageEvent, AController * EventInstigator, AActor * DamageCauser) { NativeCall<void, float*, FDamageEvent*, AController*, AActor*>(this, "APrimalCharacter.AdjustDamage", Damage, DamageEvent, EventInstigator, DamageCauser); }
    bool CanBeTargetedBy(ITargetableInterface * Attacker) { return NativeCall<bool, ITargetableInterface*>(this, "APrimalCharacter.CanBeTargetedBy", Attacker); }
    bool IsValidForCombatMusic() { return NativeCall<bool>(this, "APrimalCharacter.IsValidForCombatMusic"); }
    float TakeDamage(float Damage, FDamageEvent * DamageEvent, AController * EventInstigator, AActor * DamageCauser) { return NativeCall<float, float, FDamageEvent*, AController*, AActor*>(this, "APrimalCharacter.TakeDamage", Damage, DamageEvent, EventInstigator, DamageCauser); }
    void HurtMe(int HowMuch) { NativeCall<void, int>(this, "APrimalCharacter.HurtMe", HowMuch); }
    bool CanDie(float KillingDamage, FDamageEvent * DamageEvent, AController * Killer, AActor * DamageCauser) { return NativeCall<bool, float, FDamageEvent*, AController*, AActor*>(this, "APrimalCharacter.CanDie", KillingDamage, DamageEvent, Killer, DamageCauser); }
    bool Die(float KillingDamage, FDamageEvent * DamageEvent, AController * Killer, AActor * DamageCauser) { return NativeCall<bool, float, FDamageEvent*, AController*, AActor*>(this, "APrimalCharacter.Die", KillingDamage, DamageEvent, Killer, DamageCauser); }
    void DeathHarvestingDepleted(UPrimalHarvestingComponent * fromComponent) { NativeCall<void, UPrimalHarvestingComponent*>(this, "APrimalCharacter.DeathHarvestingDepleted", fromComponent); }
    void PlayDyingPoint_Implementation(float KillingDamage, FPointDamageEvent DamageEvent, APawn * InstigatingPawn, AActor * DamageCauser) { NativeCall<void, float, FPointDamageEvent, APawn*, AActor*>(this, "APrimalCharacter.PlayDyingPoint_Implementation", 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", KillingDamage, DamageEvent, InstigatingPawn, DamageCauser); }
    void OnRep_IsDead() { NativeCall<void>(this, "APrimalCharacter.OnRep_IsDead"); }
    void SetDeath(bool bForceRagdoll) { NativeCall<void, bool>(this, "APrimalCharacter.SetDeath", bForceRagdoll); }
    bool CanIgnoreImmobilizationTrap(TSubclassOf<APrimalStructure> TrapClass, bool* bForceTrigger) { return NativeCall<bool, TSubclassOf<APrimalStructure>, bool*>(this, "APrimalCharacter.CanIgnoreImmobilizationTrap", TrapClass, bForceTrigger); }
    void Immobilize(bool bImmobilize, AActor * UsingActor, bool bImmobilizeFalling, bool bPreventDismount) { NativeCall<void, bool, AActor*, bool, bool>(this, "APrimalCharacter.Immobilize", bImmobilize, UsingActor, bImmobilizeFalling, bPreventDismount); }
    float GetCorpseLifespan() { return NativeCall<float>(this, "APrimalCharacter.GetCorpseLifespan"); }
    void PlayDying(float KillingDamage, FDamageEvent * DamageEvent, APawn * InstigatingPawn, AActor * DamageCauser) { NativeCall<void, float, FDamageEvent*, APawn*, AActor*>(this, "APrimalCharacter.PlayDying", 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", 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", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }
    bool AllowHurtAnimation() { return NativeCall<bool>(this, "APrimalCharacter.AllowHurtAnimation"); }
    UPrimitiveComponent * GetPrimaryHitComponent() { return NativeCall<UPrimitiveComponent*>(this, "APrimalCharacter.GetPrimaryHitComponent"); }
    void PlayHitEffect(float DamageTaken, FDamageEvent * DamageEvent, APawn * PawnInstigator, AActor * DamageCauser, bool bIsLocalPath) { NativeCall<void, float, FDamageEvent*, APawn*, AActor*, bool>(this, "APrimalCharacter.PlayHitEffect", 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", bUseRagdollLocationOffset, bForceRecreateBones, bForLoading); }
    void CheckOnDinoPlatformSaddle() { NativeCall<void>(this, "APrimalCharacter.CheckOnDinoPlatformSaddle"); }
    void EndDinoPlatformDragging() { NativeCall<void>(this, "APrimalCharacter.EndDinoPlatformDragging"); }
    void ForceSleepRagdollEx() { NativeCall<void>(this, "APrimalCharacter.ForceSleepRagdollEx"); }
    void ForceSleepRagdoll() { NativeCall<void>(this, "APrimalCharacter.ForceSleepRagdoll"); }
    void ClearRagdollPhysics() { NativeCall<void>(this, "APrimalCharacter.ClearRagdollPhysics"); }
    void DoFindGoodSpot(FVector RagdollLoc, bool bClearCollisionSweep) { NativeCall<void, FVector, bool>(this, "APrimalCharacter.DoFindGoodSpot", RagdollLoc, bClearCollisionSweep); }
    void OnRep_IsSleeping() { NativeCall<void>(this, "APrimalCharacter.OnRep_IsSleeping"); }
    void SetSleeping(bool bSleeping, bool bUseRagdollLocationOffset) { NativeCall<void, bool, bool>(this, "APrimalCharacter.SetSleeping", bSleeping, bUseRagdollLocationOffset); }
    void ExecSetSleeping(bool bEnable) { NativeCall<void, bool>(this, "APrimalCharacter.ExecSetSleeping", bEnable); }
    void ExecSetPawnSleeping(bool bEnable) { NativeCall<void, bool>(this, "APrimalCharacter.ExecSetPawnSleeping", bEnable); }
    void ChangeActorTeam(int NewTeam) { NativeCall<void, int>(this, "APrimalCharacter.ChangeActorTeam", NewTeam); }
    void UpdateTribeName(FString NewTribeName) { NativeCall<void, FString>(this, "APrimalCharacter.UpdateTribeName", NewTribeName); }
    void NetUpdateTribeName_Implementation(FString * NewTribeName) { NativeCall<void, FString*>(this, "APrimalCharacter.NetUpdateTribeName_Implementation", NewTribeName); }
    float GetMaxCursorHUDDistance(AShooterPlayerController * PC) { return NativeCall<float, AShooterPlayerController*>(this, "APrimalCharacter.GetMaxCursorHUDDistance", PC); }
    void DrawHUD(AShooterHUD * HUD) { NativeCall<void, AShooterHUD*>(this, "APrimalCharacter.DrawHUD", HUD); }
    bool IsSubmerged(bool bDontCheckSwimming, bool bUseFullThreshold, bool bForceCheck, bool bFromVolumeChange) { return NativeCall<bool, bool, bool, bool, bool>(this, "APrimalCharacter.IsSubmerged", 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", AnimMontage, InPlayRate, StartSectionName, bForceTickPoseAndServerUpdateMesh, bForceTickPoseOnServer, BlendInTime, BlendOutTime); }
    void StopAnimMontage(UAnimMontage * AnimMontage) { NativeCall<void, UAnimMontage*>(this, "APrimalCharacter.StopAnimMontage", AnimMontage); }
    bool IsMontagePlaying(UAnimMontage * AnimMontage, float TimeFromEndToConsiderFinished) { return NativeCall<bool, UAnimMontage*, float>(this, "APrimalCharacter.IsMontagePlaying", AnimMontage, TimeFromEndToConsiderFinished); }
    void StopAllAnimMontages(float BlendOutTime) { NativeCall<void, float>(this, "APrimalCharacter.StopAllAnimMontages", BlendOutTime); }
    void TryGiveDefaultWeapon() { NativeCall<void>(this, "APrimalCharacter.TryGiveDefaultWeapon"); }
    void ToggleWeapon() { NativeCall<void>(this, "APrimalCharacter.ToggleWeapon"); }
    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", aDino, OrderType, enemyTarget); }
    FVector * BPModifyRightDirectionInput_Implementation(FVector * result, FVector * directionInput) { return NativeCall<FVector*, FVector*, FVector*>(this, "APrimalCharacter.BPModifyRightDirectionInput_Implementation", result, directionInput); }
    void MoveForward(float Val) { NativeCall<void, float>(this, "APrimalCharacter.MoveForward", Val); }
    void MoveRight(float Val) { NativeCall<void, float>(this, "APrimalCharacter.MoveRight", Val); }
    void MoveUp(float Val) { NativeCall<void, float>(this, "APrimalCharacter.MoveUp", Val); }
    void TurnInput(float Val) { NativeCall<void, float>(this, "APrimalCharacter.TurnInput", Val); }
    void LookInput(float Val) { NativeCall<void, float>(this, "APrimalCharacter.LookInput", Val); }
    void TurnAtRate(float Val) { NativeCall<void, float>(this, "APrimalCharacter.TurnAtRate", Val); }
    void LookUpAtRate(float Val) { NativeCall<void, float>(this, "APrimalCharacter.LookUpAtRate", Val); }
    bool IsGameInputAllowed() { return NativeCall<bool>(this, "APrimalCharacter.IsGameInputAllowed"); }
    bool IsInputAllowed() { return NativeCall<bool>(this, "APrimalCharacter.IsInputAllowed"); }
    void OnStartFire(bool bFromGamepadRight) { NativeCall<void, bool>(this, "APrimalCharacter.OnStartFire", bFromGamepadRight); }
    void OnStopFire(bool bFromGamepadRight) { NativeCall<void, bool>(this, "APrimalCharacter.OnStopFire", bFromGamepadRight); }
    void OnAltFirePressed() { NativeCall<void>(this, "APrimalCharacter.OnAltFirePressed"); }
    void OnAltFireReleased() { NativeCall<void>(this, "APrimalCharacter.OnAltFireReleased"); }
    void OnStartAltFire(bool bFromGamepad) { NativeCall<void, bool>(this, "APrimalCharacter.OnStartAltFire", bFromGamepad); }
    void OnStopAltFire(bool bFromGamepad) { NativeCall<void, bool>(this, "APrimalCharacter.OnStopAltFire", bFromGamepad); }
    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"); }
    void OnRunToggle() { NativeCall<void>(this, "APrimalCharacter.OnRunToggle"); }
    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", DeltaSeconds); }
    void ServerCaptureDermis_Implementation(APrimalCharacter * Target) { NativeCall<void, APrimalCharacter*>(this, "APrimalCharacter.ServerCaptureDermis_Implementation", Target); }
    void CaptureCharacterSnapshot(UPrimalItem * Item) { NativeCall<void, UPrimalItem*>(this, "APrimalCharacter.CaptureCharacterSnapshot", Item); }
    static void StaticApplyCharacterSnapshot(UPrimalItem * Item, AActor * To, FVector Offset, float MaxExtent, int Pose) { NativeCall<void, UPrimalItem*, AActor*, FVector, float, int>(nullptr, "APrimalCharacter.StaticApplyCharacterSnapshot", Item, To, Offset, MaxExtent, Pose); }
    static void StaticApplyCharacterSnapshotEquipment(UPrimalInventoryComponent * Inventory, AActor * To) { NativeCall<void, UPrimalInventoryComponent*, AActor*>(nullptr, "APrimalCharacter.StaticApplyCharacterSnapshotEquipment", Inventory, To); }
    static void StaticRemoveCharacterSnapshot(UPrimalItem * Item, AActor * From) { NativeCall<void, UPrimalItem*, AActor*>(nullptr, "APrimalCharacter.StaticRemoveCharacterSnapshot", Item, From); }
    static int StaticGetSnapshotPoseCount(UPrimalItem * Item) { return NativeCall<int, UPrimalItem*>(nullptr, "APrimalCharacter.StaticGetSnapshotPoseCount", Item); }
    static FPrimalSnapshotPose * StaticGetSnapshotPose(FPrimalSnapshotPose * result, UPrimalItem * Item, int PoseIndex) { return NativeCall<FPrimalSnapshotPose*, FPrimalSnapshotPose*, UPrimalItem*, int>(nullptr, "APrimalCharacter.StaticGetSnapshotPose", result, Item, PoseIndex); }
    void ApplyCharacterSnapshot(UPrimalItem * Item, AActor * To, FVector Offset, float MaxExtent, int Pose) { NativeCall<void, UPrimalItem*, AActor*, FVector, float, int>(this, "APrimalCharacter.ApplyCharacterSnapshot", Item, To, Offset, MaxExtent, Pose); }
    void RemoveCharacterSnapshot(UPrimalItem * Item, AActor * From) { NativeCall<void, UPrimalItem*, AActor*>(this, "APrimalCharacter.RemoveCharacterSnapshot", Item, From); }
    static UActorComponent * GetSnapshotComponent(AActor * From, FName Tag) { return NativeCall<UActorComponent*, AActor*, FName>(nullptr, "APrimalCharacter.GetSnapshotComponent", From, Tag); }
    static UActorComponent * CreateSnapshotComponent(AActor * For, UObject * Template, FName Tag, FName Name) { return NativeCall<UActorComponent*, AActor*, UObject*, FName, FName>(nullptr, "APrimalCharacter.CreateSnapshotComponent", For, Template, Tag, Name); }
    void ModifyStasisComponentRadius(float Delta) { NativeCall<void, float>(this, "APrimalCharacter.ModifyStasisComponentRadius", Delta); }
    void UpdateStencilValues() { NativeCall<void>(this, "APrimalCharacter.UpdateStencilValues"); }
    void Tick(float DeltaSeconds) { NativeCall<void, float>(this, "APrimalCharacter.Tick", DeltaSeconds); }
    void EndPlay(EEndPlayReason::Type EndPlayReason) { NativeCall<void, EEndPlayReason::Type>(this, "APrimalCharacter.EndPlay", EndPlayReason); }
    void SetCharacterMeshesMaterialScalarParamValue(FName ParamName, float Value) { NativeCall<void, FName, float>(this, "APrimalCharacter.SetCharacterMeshesMaterialScalarParamValue", ParamName, Value); }
    void EnableBodiesGravity() { NativeCall<void>(this, "APrimalCharacter.EnableBodiesGravity"); }
    void UpdateSwimmingState() { NativeCall<void>(this, "APrimalCharacter.UpdateSwimmingState"); }
    FVector * GetRootBodyBoneLocation(FVector * result) { return NativeCall<FVector*, FVector*>(this, "APrimalCharacter.GetRootBodyBoneLocation", result); }
    bool IsOwningClient() { return NativeCall<bool>(this, "APrimalCharacter.IsOwningClient"); }
    FVector * GetInputDirectionVector(FVector * result, bool bRelativeToViewDirection) { return NativeCall<FVector*, FVector*, bool>(this, "APrimalCharacter.GetInputDirectionVector", result, bRelativeToViewDirection); }
    void GetCharacterViewLocationAndDirection(FVector * OutViewLocation, FVector * OutViewDirection, bool* OutFromCrosshairOrCamera, float FallbackAngleOffsetDegrees) { NativeCall<void, FVector*, FVector*, bool*, float>(this, "APrimalCharacter.GetCharacterViewLocationAndDirection", 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 OnVoiceTalkingStateChanged(bool isTalking, bool IsUsingSuperRange) { NativeCall<void, bool, bool>(this, "APrimalCharacter.OnVoiceTalkingStateChanged", isTalking, IsUsingSuperRange); }
    void OnStopJump() { NativeCall<void>(this, "APrimalCharacter.OnStopJump"); }
    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty> * OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "APrimalCharacter.GetLifetimeReplicatedProps", OutLifetimeProps); }
    float GetRunningSpeedModifier(bool bIsForDefaultSpeed) { return NativeCall<float, bool>(this, "APrimalCharacter.GetRunningSpeedModifier", 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) { return NativeCall<AActor*, ECollisionChannel, UActorComponent**, float, float, int*, FHitResult*, bool, bool, bool>(this, "APrimalCharacter.GetAimedActor", CollisionChannel, HitComponent, MaxDistanceOverride, CheckRadius, hitBodyIndex, outHitResult, bForceUseCameraLocation, bForceUpdateAimedActors, bForceUseActorLocation); }
    void GetAimedActor(FHitResult * outHitResult, ECollisionChannel CollisionChannel, float MaxDistanceOverride, float CheckRadius, bool bForceUseCameraLocation, bool bForceUpdateAimedActors) { NativeCall<void, FHitResult*, ECollisionChannel, float, float, bool, bool>(this, "APrimalCharacter.GetAimedActor", outHitResult, CollisionChannel, MaxDistanceOverride, CheckRadius, bForceUseCameraLocation, bForceUpdateAimedActors); }
    void OnPrimalCharacterSleeped() { NativeCall<void>(this, "APrimalCharacter.OnPrimalCharacterSleeped"); }
    void OnPrimalCharacterUnsleeped() { NativeCall<void>(this, "APrimalCharacter.OnPrimalCharacterUnsleeped"); }
    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", 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", 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", 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", AnimMontage, PlayRate, ServerCurrentMontageTime, bForceTickPoseAndServerUpdateMesh, BlendInTime, BlendOutTime); }
    void ClientStopAnimation_Implementation(UAnimMontage * AnimMontage, bool bStopOnOwner, float BlendOutTime) { NativeCall<void, UAnimMontage*, bool, float>(this, "APrimalCharacter.ClientStopAnimation_Implementation", AnimMontage, bStopOnOwner, BlendOutTime); }
    float StartSyncedMontage(UAnimMontage * AnimMontage, float PlayRate, float BlendInTime, float BlendOutTime) { return NativeCall<float, UAnimMontage*, float, float, float>(this, "APrimalCharacter.StartSyncedMontage", AnimMontage, PlayRate, BlendInTime, BlendOutTime); }
    void StopSyncedMontage(float BlendOutTime, bool bAutoStopAnim) { NativeCall<void, float, bool>(this, "APrimalCharacter.StopSyncedMontage", BlendOutTime, bAutoStopAnim); }
    void SetRunning(bool bNewRunning) { NativeCall<void, bool>(this, "APrimalCharacter.SetRunning", bNewRunning); }
    void ServerSetRunning_Implementation(bool bNewRunning) { NativeCall<void, bool>(this, "APrimalCharacter.ServerSetRunning_Implementation", bNewRunning); }
    void UpdateRunSounds(bool bNewRunning) { NativeCall<void, bool>(this, "APrimalCharacter.UpdateRunSounds", bNewRunning); }
    void ControllerLeavingGame(AShooterPlayerController * theController) { NativeCall<void, AShooterPlayerController*>(this, "APrimalCharacter.ControllerLeavingGame", 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); }
    FString * GetShortName(FString * result) { return NativeCall<FString*, FString*>(this, "APrimalCharacter.GetShortName", result); }
    TArray<FString> * GetDetailedDescription(TArray<FString> * result, FString * IndentPrefix) { return NativeCall<TArray<FString>*, TArray<FString>*, FString*>(this, "APrimalCharacter.GetDetailedDescription", result, IndentPrefix); }
    float GetHealthPercentage() { return NativeCall<float>(this, "APrimalCharacter.GetHealthPercentage"); }
    float GetHealth() { return NativeCall<float>(this, "APrimalCharacter.GetHealth"); }
    FVector * GetInterpolatedLocation(FVector * result) { return NativeCall<FVector*, FVector*>(this, "APrimalCharacter.GetInterpolatedLocation", result); }
    void DrawFloatingChatMessage(AShooterHUD * HUD, FString Message, long double receivedChatTime) { NativeCall<void, AShooterHUD*, FString, long double>(this, "APrimalCharacter.DrawFloatingChatMessage", HUD, Message, receivedChatTime); }
    FRotator * GetInterpolatedRotation(FRotator * result) { return NativeCall<FRotator*, FRotator*>(this, "APrimalCharacter.GetInterpolatedRotation", result); }
    FRotator * GetInterpolatedRotation_NonFlattened(FRotator * result) { return NativeCall<FRotator*, FRotator*>(this, "APrimalCharacter.GetInterpolatedRotation_NonFlattened", result); }
    float GetClientRotationInterpSpeed(FVector * RootLoc) { return NativeCall<float, FVector*>(this, "APrimalCharacter.GetClientRotationInterpSpeed", RootLoc); }
    FRotator * GetAimOffsets(FRotator * result, float DeltaTime, FRotator * RootRotOffset, float* RootYawSpeed, float MaxYawAimClamp, FVector * RootLocOffset) { return NativeCall<FRotator*, FRotator*, float, FRotator*, float*, float, FVector*>(this, "APrimalCharacter.GetAimOffsets", result, DeltaTime, RootRotOffset, RootYawSpeed, MaxYawAimClamp, RootLocOffset); }
    void ForceRefreshBones() { NativeCall<void>(this, "APrimalCharacter.ForceRefreshBones"); }
    void StartForceSkelUpdate(float ForTime, bool bForceUpdateMesh, bool bServerOnly) { NativeCall<void, float, bool, bool>(this, "APrimalCharacter.StartForceSkelUpdate", ForTime, bForceUpdateMesh, bServerOnly); }
    void EndForceSkelUpdate() { NativeCall<void>(this, "APrimalCharacter.EndForceSkelUpdate"); }
    void ForceMeshRelevant(float Duration) { NativeCall<void, float>(this, "APrimalCharacter.ForceMeshRelevant", Duration); }
    bool IsConscious() { return NativeCall<bool>(this, "APrimalCharacter.IsConscious"); }
    void Stasis() { NativeCall<void>(this, "APrimalCharacter.Stasis"); }
    void Unstasis() { NativeCall<void>(this, "APrimalCharacter.Unstasis"); }
    bool AllowFallDamage(FHitResult * HitResult, float FallDamageAmount, bool CustomFallDamage) { return NativeCall<bool, FHitResult*, float, bool>(this, "APrimalCharacter.AllowFallDamage", HitResult, FallDamageAmount, CustomFallDamage); }
    bool IsSimulated() { return NativeCall<bool>(this, "APrimalCharacter.IsSimulated"); }
    bool IsWildSlow() { return NativeCall<bool>(this, "APrimalCharacter.IsWildSlow"); }
    UPrimalCharacterStatusComponent * GetCharacterStatusComponent() { return NativeCall<UPrimalCharacterStatusComponent*>(this, "APrimalCharacter.GetCharacterStatusComponent"); }
    float GetBaseStatusValue(TEnumAsByte<enum EPrimalCharacterStatusValue::Type> StatusValueType) { return NativeCall<float, TEnumAsByte<enum EPrimalCharacterStatusValue::Type>>(this, "APrimalCharacter.GetBaseStatusValue", StatusValueType); }
    void DrawLocalPlayerHUD(AShooterHUD * HUD) { NativeCall<void, AShooterHUD*>(this, "APrimalCharacter.DrawLocalPlayerHUD", HUD); }
    bool IsInStatusState(EPrimalCharacterStatusState::Type StatusStateType) { return NativeCall<bool, EPrimalCharacterStatusState::Type>(this, "APrimalCharacter.IsInStatusState", StatusStateType); }
    float GetCurrentStatusValue(EPrimalCharacterStatusValue::Type StatusValueType) { return NativeCall<float, EPrimalCharacterStatusValue::Type>(this, "APrimalCharacter.GetCurrentStatusValue", StatusValueType); }
    float GetMaxStatusValue(EPrimalCharacterStatusValue::Type StatusValueType) { return NativeCall<float, EPrimalCharacterStatusValue::Type>(this, "APrimalCharacter.GetMaxStatusValue", StatusValueType); }
    float GetPercentStatusValue(EPrimalCharacterStatusValue::Type StatusValueType) { return NativeCall<float, EPrimalCharacterStatusValue::Type>(this, "APrimalCharacter.GetPercentStatusValue", StatusValueType); }
    bool IsValidForStatusUpdate() { return NativeCall<bool>(this, "APrimalCharacter.IsValidForStatusUpdate"); }
    float GetMaxSpeedModifier() { return NativeCall<float>(this, "APrimalCharacter.GetMaxSpeedModifier"); }
    float BP_GetMaxSpeedModifier() { return NativeCall<float>(this, "APrimalCharacter.BP_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", Pawn); }
    float GetDefaultMovementSpeed() { return NativeCall<float>(this, "APrimalCharacter.GetDefaultMovementSpeed"); }
    void TakeFallingDamage(FHitResult * Hit) { NativeCall<void, FHitResult*>(this, "APrimalCharacter.TakeFallingDamage", Hit); }
    void ApplyCustomFallDamage(FVector * Location, FVector * Velocity, float FallDamageThreshold) { NativeCall<void, FVector*, FVector*, float>(this, "APrimalCharacter.ApplyCustomFallDamage", Location, Velocity, FallDamageThreshold); }
    void OnLanded(FHitResult * Hit) { NativeCall<void, FHitResult*>(this, "APrimalCharacter.OnLanded", 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", ByController); }
    void LocalUnpossessed_Implementation() { NativeCall<void>(this, "APrimalCharacter.LocalUnpossessed_Implementation"); }
    void PlayFootstep() { NativeCall<void>(this, "APrimalCharacter.PlayFootstep"); }
    EPhysicalSurface GetFootPhysicalSurfaceType(bool bForce, bool bIsForFootstepParticles) { return NativeCall<EPhysicalSurface, bool, bool>(this, "APrimalCharacter.GetFootPhysicalSurfaceType", bForce, bIsForFootstepParticles); }
    EPhysicalSurface GetPhysMatTypeFromHit(FHitResult * FromHit) { return NativeCall<EPhysicalSurface, FHitResult*>(this, "APrimalCharacter.GetPhysMatTypeFromHit", FromHit); }
    EPhysicalSurface GetPhysMatTypeFromHits(TArray<FHitResult> * FromHits) { return NativeCall<EPhysicalSurface, TArray<FHitResult>*>(this, "APrimalCharacter.GetPhysMatTypeFromHits", FromHits); }
    bool ModifyInputAcceleration(FVector * InputAcceleration) { return NativeCall<bool, FVector*>(this, "APrimalCharacter.ModifyInputAcceleration", InputAcceleration); }
    bool ShouldAttackStopMoveCollapsing() { return NativeCall<bool>(this, "APrimalCharacter.ShouldAttackStopMoveCollapsing"); }
    bool AnimationPreventsInput() { return NativeCall<bool>(this, "APrimalCharacter.AnimationPreventsInput"); }
    bool BP_AnimationPreventsInput() { return NativeCall<bool>(this, "APrimalCharacter.BP_AnimationPreventsInput"); }
    float SetHealth(float newHealth) { return NativeCall<float, float>(this, "APrimalCharacter.SetHealth", newHealth); }
    bool IsOfTribe(int ID) { return NativeCall<bool, int>(this, "APrimalCharacter.IsOfTribe", ID); }
    void SetRagdollReplication(bool Enabled) { NativeCall<void, bool>(this, "APrimalCharacter.SetRagdollReplication", Enabled); }
    void Serialize(FArchive * Ar) { NativeCall<void, FArchive*>(this, "APrimalCharacter.Serialize", 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(TArray<FVector_NetQuantize> * BoneLocations, FRotator_NetQuantize TargetRootRotation) { NativeCall<void, TArray<FVector_NetQuantize>*, FRotator_NetQuantize>(this, "APrimalCharacter.ClientRagdollUpdate_Implementation", BoneLocations, TargetRootRotation); }
    void SleepBodies() { NativeCall<void>(this, "APrimalCharacter.SleepBodies"); }
    void UpdateRagdollReplicationOnClient() { NativeCall<void>(this, "APrimalCharacter.UpdateRagdollReplicationOnClient"); }
    void ClientEndRagdollUpdate_Implementation() { NativeCall<void>(this, "APrimalCharacter.ClientEndRagdollUpdate_Implementation"); }
    void OnRep_RagdollPositions() { NativeCall<void>(this, "APrimalCharacter.OnRep_RagdollPositions"); }
    void InitRagdollReplication() { NativeCall<void>(this, "APrimalCharacter.InitRagdollReplication"); }
    bool IsDraggingCharacter() { return NativeCall<bool>(this, "APrimalCharacter.IsDraggingCharacter"); }
    void EndDragCharacter() { NativeCall<void>(this, "APrimalCharacter.EndDragCharacter"); }
    bool CanDragCharacter(APrimalCharacter * Character) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalCharacter.CanDragCharacter", Character); }
    bool CanBeDragged() { return NativeCall<bool>(this, "APrimalCharacter.CanBeDragged"); }
    bool IsInvincible() { return NativeCall<bool>(this, "APrimalCharacter.IsInvincible"); }
    int GetNearestBoneIndexForDrag(APrimalCharacter * Character, FVector HitLocation) { return NativeCall<int, APrimalCharacter*, FVector>(this, "APrimalCharacter.GetNearestBoneIndexForDrag", Character, HitLocation); }
    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", Dragged, BoneIndex, bWithGrapHook); }
    void OnEndDrag_Implementation() { NativeCall<void>(this, "APrimalCharacter.OnEndDrag_Implementation"); }
    void OnBeginDragged(APrimalCharacter * Dragger) { NativeCall<void, APrimalCharacter*>(this, "APrimalCharacter.OnBeginDragged", Dragger); }
    void OnEndDragged(APrimalCharacter * Dragger) { NativeCall<void, APrimalCharacter*>(this, "APrimalCharacter.OnEndDragged", Dragger); }
    bool CanBeCarried(APrimalCharacter * ByCarrier) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalCharacter.CanBeCarried", ByCarrier); }
    float GetKillXP() { return NativeCall<float>(this, "APrimalCharacter.GetKillXP"); }
    void UpdateIK() { NativeCall<void>(this, "APrimalCharacter.UpdateIK"); }
    void SetEnableIK(bool bEnable) { NativeCall<void, bool>(this, "APrimalCharacter.SetEnableIK", bEnable); }
    void EnableIK(bool bEnable, bool bForceOnDedicated) { NativeCall<void, bool, bool>(this, "APrimalCharacter.EnableIK", bEnable, bForceOnDedicated); }
    bool TryMultiUse(APlayerController * ForPC, int UseIndex) { return NativeCall<bool, APlayerController*, int>(this, "APrimalCharacter.TryMultiUse", ForPC, UseIndex); }
    void ClientMultiUse(APlayerController * ForPC, int UseIndex) { NativeCall<void, APlayerController*, int>(this, "APrimalCharacter.ClientMultiUse", ForPC, UseIndex); }
    void GetHUDElements(APlayerController * ForPC, TArray<FHUDElement> * OutElements) { NativeCall<void, APlayerController*, TArray<FHUDElement>*>(this, "APrimalCharacter.GetHUDElements", ForPC, OutElements); }
    void RefreshBiomeZoneVolumes() { NativeCall<void>(this, "APrimalCharacter.RefreshBiomeZoneVolumes"); }
    void ForceTickPoseDelta() { NativeCall<void>(this, "APrimalCharacter.ForceTickPoseDelta"); }
    void CheckJumpOutOfWater() { NativeCall<void>(this, "APrimalCharacter.CheckJumpOutOfWater"); }
    bool IsTargetableDead() { return NativeCall<bool>(this, "APrimalCharacter.IsTargetableDead"); }
    EShooterPhysMaterialType::Type GetTargetableDamageFXDefaultPhysMaterial() { return NativeCall<EShooterPhysMaterialType::Type>(this, "APrimalCharacter.GetTargetableDamageFXDefaultPhysMaterial"); }
    bool Poop(bool bForcePoop) { return NativeCall<bool, bool>(this, "APrimalCharacter.Poop", bForcePoop); }
    void EmitPoop() { NativeCall<void>(this, "APrimalCharacter.EmitPoop"); }
    bool IsValidForStatusRecovery() { return NativeCall<bool>(this, "APrimalCharacter.IsValidForStatusRecovery"); }
    bool GetGroundLocation(FVector * theGroundLoc, FVector * OffsetUp, FVector * OffsetDown) { return NativeCall<bool, FVector*, FVector*, FVector*>(this, "APrimalCharacter.GetGroundLocation", theGroundLoc, OffsetUp, OffsetDown); }
    void DeathHarvestingFadeOut_Implementation() { NativeCall<void>(this, "APrimalCharacter.DeathHarvestingFadeOut_Implementation"); }
    void ServerUploadCharacter(AShooterPlayerController * UploadedBy) { NativeCall<void, AShooterPlayerController*>(this, "APrimalCharacter.ServerUploadCharacter", UploadedBy); }
    FRotator * GetBaseAimRotation(FRotator * result) { return NativeCall<FRotator*, FRotator*>(this, "APrimalCharacter.GetBaseAimRotation", result); }
    void ApplyDamageMomentum(float DamageTaken, FDamageEvent * DamageEvent, APawn * PawnInstigator, AActor * DamageCauser) { NativeCall<void, float, FDamageEvent*, APawn*, AActor*>(this, "APrimalCharacter.ApplyDamageMomentum", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }
    void NetAddCharacterMovementImpulse_Implementation(FVector Impulse, bool bVelChange, float ImpulseExponent, bool bSetNewMovementMode, EMovementMode NewMovementMode, bool bOverrideMaxImpulseZ) { NativeCall<void, FVector, bool, float, bool, EMovementMode, bool>(this, "APrimalCharacter.NetAddCharacterMovementImpulse_Implementation", Impulse, bVelChange, ImpulseExponent, bSetNewMovementMode, NewMovementMode, bOverrideMaxImpulseZ); }
    void NetSetCharacterMovementVelocity_Implementation(bool bSetNewVelocity, FVector NewVelocity, bool bSetNewMovementMode, EMovementMode NewMovementMode) { NativeCall<void, bool, FVector, bool, EMovementMode>(this, "APrimalCharacter.NetSetCharacterMovementVelocity_Implementation", bSetNewVelocity, NewVelocity, bSetNewMovementMode, NewMovementMode); }
    bool AllowSaving() { return NativeCall<bool>(this, "APrimalCharacter.AllowSaving"); }
    bool IsWatered() { return NativeCall<bool>(this, "APrimalCharacter.IsWatered"); }
    void LoadedFromSaveGame() { NativeCall<void>(this, "APrimalCharacter.LoadedFromSaveGame"); }
    FVector * GetTargetingLocation(FVector * result, AActor * Attacker) { return NativeCall<FVector*, FVector*, AActor*>(this, "APrimalCharacter.GetTargetingLocation", result, Attacker); }
    int LevelUpPlayerAddedStat(TEnumAsByte<enum EPrimalCharacterStatusValue::Type> StatToLevel, int NumLevels, AShooterPlayerController * ForPlayer) { return NativeCall<int, TEnumAsByte<enum EPrimalCharacterStatusValue::Type>, int, AShooterPlayerController*>(this, "APrimalCharacter.LevelUpPlayerAddedStat", StatToLevel, NumLevels, ForPlayer); }
    void CheckJumpInput(float DeltaTime) { NativeCall<void, float>(this, "APrimalCharacter.CheckJumpInput", 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"); }
    bool TryAccessInventory() { return NativeCall<bool>(this, "APrimalCharacter.TryAccessInventory"); }
    bool IsRagdolled() { return NativeCall<bool>(this, "APrimalCharacter.IsRagdolled"); }
    static void ForceUpdateAimedCharacters(UWorld * World, FVector * StartLoc, FVector * EndLoc, AActor * IgnoreActor, bool bForceUpdateIgnoreActor, float TraceRadius) { NativeCall<void, UWorld*, FVector*, FVector*, AActor*, bool, float>(nullptr, "APrimalCharacter.ForceUpdateAimedCharacters", World, StartLoc, EndLoc, IgnoreActor, bForceUpdateIgnoreActor, TraceRadius); }
    void NetForceUpdateAimedCharacters_Implementation(FVector StartLoc, FVector EndLoc, AActor * IgnoreActor, bool bForceUpdateIgnoreActor, float TraceRadius) { NativeCall<void, FVector, FVector, AActor*, bool, float>(this, "APrimalCharacter.NetForceUpdateAimedCharacters_Implementation", StartLoc, EndLoc, IgnoreActor, bForceUpdateIgnoreActor, TraceRadius); }
    static void ForceUpdateCharacter(UWorld * World, APrimalCharacter * primalChar) { NativeCall<void, UWorld*, APrimalCharacter*>(nullptr, "APrimalCharacter.ForceUpdateCharacter", World, primalChar); }
    bool HasBuff(TSubclassOf<APrimalBuff> BuffClass, bool useExactMatch) { return NativeCall<bool, TSubclassOf<APrimalBuff>, bool>(this, "APrimalCharacter.HasBuff", BuffClass, useExactMatch); }
    bool HasBuffWithCustomTag(FName buffCustomTag) { return NativeCall<bool, FName>(this, "APrimalCharacter.HasBuffWithCustomTag", buffCustomTag); }
    int GetBuffStackCount(TSubclassOf<APrimalBuff> BuffClass, bool useExactMatch) { return NativeCall<int, TSubclassOf<APrimalBuff>, bool>(this, "APrimalCharacter.GetBuffStackCount", BuffClass, useExactMatch); }
    APrimalBuff * GetBuff(TSubclassOf<APrimalBuff> BuffClass) { return NativeCall<APrimalBuff*, TSubclassOf<APrimalBuff>>(this, "APrimalCharacter.GetBuff", BuffClass); }
    APrimalBuff * GetBuffWithCustomTag(FName BuffCustomTag) { return NativeCall<APrimalBuff*, FName>(this, "APrimalCharacter.GetBuffWithCustomTag", BuffCustomTag); }
    void GetAllBuffs(TArray<APrimalBuff*> * AllBuffs) { NativeCall<void, TArray<APrimalBuff*>*>(this, "APrimalCharacter.GetAllBuffs", AllBuffs); }
    void GetBuffs(TArray<APrimalBuff*> * TheBuffs) { NativeCall<void, TArray<APrimalBuff*>*>(this, "APrimalCharacter.GetBuffs", TheBuffs); }
    APrimalBuff * GetBuffForPostEffect(UMaterialInterface * anEffect) { return NativeCall<APrimalBuff*, UMaterialInterface*>(this, "APrimalCharacter.GetBuffForPostEffect", anEffect); }
    void RemoveAllJumpDeactivatedBuffs(APrimalBuff * IgnoredBuff) { NativeCall<void, APrimalBuff*>(this, "APrimalCharacter.RemoveAllJumpDeactivatedBuffs", IgnoredBuff); }
    void OnStartTargeting(bool bFromGamepadLeft) { NativeCall<void, bool>(this, "APrimalCharacter.OnStartTargeting", bFromGamepadLeft); }
    void OnStopTargeting(bool bFromGamepadLeft) { NativeCall<void, bool>(this, "APrimalCharacter.OnStopTargeting", bFromGamepadLeft); }
    void AttachGPSTransponder(APrimalStructureExplosiveTransGPS * Transponder) { NativeCall<void, APrimalStructureExplosiveTransGPS*>(this, "APrimalCharacter.AttachGPSTransponder", Transponder); }
    void UpdateNetDynamicMusic() { NativeCall<void>(this, "APrimalCharacter.UpdateNetDynamicMusic"); }
    void NetPlaySoundOnCharacter_Implementation(USoundBase * SoundToPlay, bool bPlayOnOwner) { NativeCall<void, USoundBase*, bool>(this, "APrimalCharacter.NetPlaySoundOnCharacter_Implementation", 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"); }
    float GetCarryingSocketYaw(bool RefreshBones) { return NativeCall<float, bool>(this, "APrimalCharacter.GetCarryingSocketYaw", RefreshBones); }
    void SetCarryingDino(APrimalDinoCharacter * aDino) { NativeCall<void, APrimalDinoCharacter*>(this, "APrimalCharacter.SetCarryingDino", aDino); }
    void ClearCarryingDino(bool bFromDino, bool bCancelAnyCarryBuffs) { NativeCall<void, bool, bool>(this, "APrimalCharacter.ClearCarryingDino", bFromDino, bCancelAnyCarryBuffs); }
    void OnAttachedToCharacter() { NativeCall<void>(this, "APrimalCharacter.OnAttachedToCharacter"); }
    void OnDetachedFromCharacter(APrimalCharacter * aCharacter, int OverrideDirection) { NativeCall<void, APrimalCharacter*, int>(this, "APrimalCharacter.OnDetachedFromCharacter", aCharacter, OverrideDirection); }
    void ClearMountedDino(bool fromMountedDino) { NativeCall<void, bool>(this, "APrimalCharacter.ClearMountedDino", fromMountedDino); }
    bool DinoMountOnMe(APrimalDinoCharacter * dinoCharacter) { return NativeCall<bool, APrimalDinoCharacter*>(this, "APrimalCharacter.DinoMountOnMe", dinoCharacter); }
    bool CanMountOnMe(APrimalDinoCharacter * dinoCharacter) { return NativeCall<bool, APrimalDinoCharacter*>(this, "APrimalCharacter.CanMountOnMe", dinoCharacter); }
    void OnRep_MountedDino() { NativeCall<void>(this, "APrimalCharacter.OnRep_MountedDino"); }
    bool HasCryoSickness() { return NativeCall<bool>(this, "APrimalCharacter.HasCryoSickness"); }
    float GetDragWeight(APrimalCharacter * ForDragger) { return NativeCall<float, APrimalCharacter*>(this, "APrimalCharacter.GetDragWeight", ForDragger); }
    void SetBase(UPrimitiveComponent * NewBaseComponent, FName BoneName, bool bNotifyPawn) { NativeCall<void, UPrimitiveComponent*, FName, bool>(this, "APrimalCharacter.SetBase", NewBaseComponent, BoneName, bNotifyPawn); }
    void UnPossessed() { NativeCall<void>(this, "APrimalCharacter.UnPossessed"); }
    void TryCallAttackTarget() { NativeCall<void>(this, "APrimalCharacter.TryCallAttackTarget"); }
    void TryCallMoveTo() { NativeCall<void>(this, "APrimalCharacter.TryCallMoveTo"); }
    UTexture2D * GetOverrideDefaultCharacterParamTexture(FName theParamName, UTexture2D * CurrentTexture) { return NativeCall<UTexture2D*, FName, UTexture2D*>(this, "APrimalCharacter.GetOverrideDefaultCharacterParamTexture", theParamName, CurrentTexture); }
    bool CanBePainted() { return NativeCall<bool>(this, "APrimalCharacter.CanBePainted"); }
    UPaintingTexture * GetPaintingTexture() { return NativeCall<UPaintingTexture*>(this, "APrimalCharacter.GetPaintingTexture"); }
    void OnRep_PaintingComponent() { NativeCall<void>(this, "APrimalCharacter.OnRep_PaintingComponent"); }
    bool AllowColoringBy(APlayerController * ForPC, UObject * anItem) { return NativeCall<bool, APlayerController*, UObject*>(this, "APrimalCharacter.AllowColoringBy", ForPC, anItem); }
    FVector * GetFloatingHUDLocation(FVector * result) { return NativeCall<FVector*, FVector*>(this, "APrimalCharacter.GetFloatingHUDLocation", result); }
    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", ForBuffClass, ForInstigatorItem, perfectClassMatch); }
    bool ExcludePostProcessBlendableMaterial(UMaterialInterface * BlendableMaterialInterface) { return NativeCall<bool, UMaterialInterface*>(this, "APrimalCharacter.ExcludePostProcessBlendableMaterial", BlendableMaterialInterface); }
    FVector * GetVelocity(FVector * result, bool bIsForRagdoll) { return NativeCall<FVector*, FVector*, bool>(this, "APrimalCharacter.GetVelocity", result, bIsForRagdoll); }
    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); }
    long double GetLastCausedDamageTime() { return NativeCall<long double>(this, "APrimalCharacter.GetLastCausedDamageTime"); }
    void SetLastCausedDamageTime(const long double lastCausedDamageTime) { NativeCall<void, const long double>(this, "APrimalCharacter.SetLastCausedDamageTime", lastCausedDamageTime); }
    bool SimulatedPreventBasedPhysics() { return NativeCall<bool>(this, "APrimalCharacter.SimulatedPreventBasedPhysics"); }
    bool AllowMovementMode(EMovementMode NewMovementMode, char NewCustomMode) { return NativeCall<bool, EMovementMode, char>(this, "APrimalCharacter.AllowMovementMode", NewMovementMode, NewCustomMode); }
    APrimalDinoCharacter * GetBasedOrSeatingOnDino() { return NativeCall<APrimalDinoCharacter*>(this, "APrimalCharacter.GetBasedOrSeatingOnDino"); }
    APrimalDinoCharacter * GetBasedOnDino() { return NativeCall<APrimalDinoCharacter*>(this, "APrimalCharacter.GetBasedOnDino"); }
    FVector * GetTargetPathfindingLocation(FVector * result, AActor * Attacker) { return NativeCall<FVector*, FVector*, AActor*>(this, "APrimalCharacter.GetTargetPathfindingLocation", result, Attacker); }
    void ClientHandleNetDestroy() { NativeCall<void>(this, "APrimalCharacter.ClientHandleNetDestroy"); }
    bool UseClearOnConsumeInput() { return NativeCall<bool>(this, "APrimalCharacter.UseClearOnConsumeInput"); }
    float GetDamageTorpidityIncreaseMultiplierScale() { return NativeCall<float>(this, "APrimalCharacter.GetDamageTorpidityIncreaseMultiplierScale"); }
    float GetIndirectTorpidityIncreaseMultiplierScale() { return NativeCall<float>(this, "APrimalCharacter.GetIndirectTorpidityIncreaseMultiplierScale"); }
    bool BPIsBasedOnDynamicActor() { return NativeCall<bool>(this, "APrimalCharacter.BPIsBasedOnDynamicActor"); }
    void NotifyBumpedByPawn(APrimalCharacter * ByPawn) { NativeCall<void, APrimalCharacter*>(this, "APrimalCharacter.NotifyBumpedByPawn", ByPawn); }
    void NotifyBumpedPawn(APawn * BumpedPawn) { NativeCall<void, APawn*>(this, "APrimalCharacter.NotifyBumpedPawn", BumpedPawn); }
    ENetRole GetRole() { return NativeCall<ENetRole>(this, "APrimalCharacter.GetRole"); }
    void SetMyInventoryComponent(UPrimalInventoryComponent * theInventoryComponent) { NativeCall<void, UPrimalInventoryComponent*>(this, "APrimalCharacter.SetMyInventoryComponent", theInventoryComponent); }
    FVector * GetTPVCameraOffset(FVector * result) { return NativeCall<FVector*, FVector*>(this, "APrimalCharacter.GetTPVCameraOffset", result); }
    FVector * GetTPVCameraOffsetMultiplier(FVector * result) { return NativeCall<FVector*, FVector*>(this, "APrimalCharacter.GetTPVCameraOffsetMultiplier", result); }
    bool UseCenteredTPVCamera() { return NativeCall<bool>(this, "APrimalCharacter.UseCenteredTPVCamera"); }
    void PossessedBy(AController * NewController) { NativeCall<void, AController*>(this, "APrimalCharacter.PossessedBy", NewController); }
    bool IsBlockedByShield(FHitResult * HitInfo, FVector * ShotDirection, bool bBlockAllPointDamage) { return NativeCall<bool, FHitResult*, FVector*, bool>(this, "APrimalCharacter.IsBlockedByShield", HitInfo, ShotDirection, bBlockAllPointDamage); }
    void BPNetAddCharacterMovementImpulse(FVector Impulse, bool bVelChange, float ImpulseExponent, bool bSetNewMovementMode, EMovementMode NewMovementMode, bool bOverrideMaxImpulseZ, bool bApplyToBigPawns) { NativeCall<void, FVector, bool, float, bool, EMovementMode, bool, bool>(this, "APrimalCharacter.BPNetAddCharacterMovementImpulse", Impulse, bVelChange, ImpulseExponent, bSetNewMovementMode, NewMovementMode, bOverrideMaxImpulseZ, bApplyToBigPawns); }
    void BPNetSetCharacterMovementVelocity(bool bSetNewVelocity, FVector NewVelocity, bool bSetNewMovementMode, EMovementMode NewMovementMode) { NativeCall<void, bool, FVector, bool, EMovementMode>(this, "APrimalCharacter.BPNetSetCharacterMovementVelocity", bSetNewVelocity, NewVelocity, bSetNewMovementMode, NewMovementMode); }
    float GetGravityZScale() { return NativeCall<float>(this, "APrimalCharacter.GetGravityZScale"); }
    void GetCharactersGrappledToMe(TArray<APrimalCharacter*> * GrappledCharsArray) { NativeCall<void, TArray<APrimalCharacter*>*>(this, "APrimalCharacter.GetCharactersGrappledToMe", GrappledCharsArray); }
    float GetFallAcceleration() { return NativeCall<float>(this, "APrimalCharacter.GetFallAcceleration"); }
    void OnMovementModeChanged(EMovementMode PrevMovementMode, char PreviousCustomMode) { NativeCall<void, EMovementMode, char>(this, "APrimalCharacter.OnMovementModeChanged", PrevMovementMode, PreviousCustomMode); }
    void EnableBPTimerServer(bool bEnable) { NativeCall<void, bool>(this, "APrimalCharacter.EnableBPTimerServer", bEnable); }
    void EnableBPTimerNonDedicated(bool bEnable) { NativeCall<void, bool>(this, "APrimalCharacter.EnableBPTimerNonDedicated", bEnable); }
    void SetCharacterAndRagdollLocation(FVector NewLocation) { NativeCall<void, FVector>(this, "APrimalCharacter.SetCharacterAndRagdollLocation", 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 DownCallOne() { NativeCall<void>(this, "APrimalCharacter.DownCallOne"); }
    float BPModifyFOV_Implementation(float FOVIn) { return NativeCall<float, float>(this, "APrimalCharacter.BPModifyFOV_Implementation", 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(FVector * InitialVelocity, const float* Friction, float DeltaTime) { NativeCall<void, FVector*, const float*, float>(this, "APrimalCharacter.OverrideWalkingVelocity", InitialVelocity, Friction, DeltaTime); }
    void OverrideSwimmingVelocity(FVector * InitialVelocity, FVector * Gravity, const float* FluidFriction, const float* NetBuoyancy, float DeltaTime) { NativeCall<void, FVector*, FVector*, const float*, const float*, float>(this, "APrimalCharacter.OverrideSwimmingVelocity", InitialVelocity, Gravity, FluidFriction, NetBuoyancy, DeltaTime); }
    void OverrideNewFallVelocity(FVector * InitialVelocity, FVector * Gravity, float DeltaTime) { NativeCall<void, FVector*, FVector*, float>(this, "APrimalCharacter.OverrideNewFallVelocity", InitialVelocity, Gravity, DeltaTime); }
    bool PreventLanding(FVector ImpactPoint, FVector ImpactAccel, FVector * Velocity) { return NativeCall<bool, FVector, FVector, FVector*>(this, "APrimalCharacter.PreventLanding", ImpactPoint, ImpactAccel, Velocity); }
    bool AllowOverrideFlyingVelocity() { return NativeCall<bool>(this, "APrimalCharacter.AllowOverrideFlyingVelocity"); }
    void OverrideFlyingVelocity(FVector * InitialVelocity, FVector * Gravity, float DeltaTime) { NativeCall<void, FVector*, FVector*, float>(this, "APrimalCharacter.OverrideFlyingVelocity", InitialVelocity, Gravity, DeltaTime); }
    void SetDynamicMusic(USoundBase * newMusic) { NativeCall<void, USoundBase*>(this, "APrimalCharacter.SetDynamicMusic", newMusic); }
    bool PreventsTargeting_Implementation(AActor * ByActor) { return NativeCall<bool, AActor*>(this, "APrimalCharacter.PreventsTargeting_Implementation", ByActor); }
    bool PreventInputType(EPrimalCharacterInputType::Type inputType) { return NativeCall<bool, EPrimalCharacterInputType::Type>(this, "APrimalCharacter.PreventInputType", inputType); }
    bool PreventInputDoesOffset() { return NativeCall<bool>(this, "APrimalCharacter.PreventInputDoesOffset"); }
    float GetImmersionDepth(bool bUseLineTrace) { return NativeCall<float, bool>(this, "APrimalCharacter.GetImmersionDepth", bUseLineTrace); }
    bool IsAlliedWithOtherTeam(int OtherTeamID) { return NativeCall<bool, int>(this, "APrimalCharacter.IsAlliedWithOtherTeam", OtherTeamID); }
    void TickMovementComponent(float DeltaTime) { NativeCall<void, float>(this, "APrimalCharacter.TickMovementComponent", DeltaTime); }
    void ResetCollisionSweepLocation(FVector * newLocation) { NativeCall<void, FVector*>(this, "APrimalCharacter.ResetCollisionSweepLocation", newLocation); }
    void DidTeleport_Implementation(FVector newLoc, FRotator newRot) { NativeCall<void, FVector, FRotator>(this, "APrimalCharacter.DidTeleport_Implementation", newLoc, newRot); }
    void FinalLoadedFromSaveGame() { NativeCall<void>(this, "APrimalCharacter.FinalLoadedFromSaveGame"); }
    void DoExecuteActorConstruction(FTransform * Transform, bool bIsDefaultTransform) { NativeCall<void, FTransform*, bool>(this, "APrimalCharacter.DoExecuteActorConstruction", Transform, bIsDefaultTransform); }
    FString * PlayerCommand_Implementation(FString * result, FString * TheCommand) { return NativeCall<FString*, FString*, FString*>(this, "APrimalCharacter.PlayerCommand_Implementation", result, TheCommand); }
    void UpdateSimulatedPosition(FVector * NewLocation, FRotator * NewRotation) { NativeCall<void, FVector*, FRotator*>(this, "APrimalCharacter.UpdateSimulatedPosition", NewLocation, NewRotation); }
    void NotifyItemQuantityUpdated(UPrimalItem * anItem, int amount) { NativeCall<void, UPrimalItem*, int>(this, "APrimalCharacter.NotifyItemQuantityUpdated", anItem, amount); }
    void NotifyItemAdded(UPrimalItem * anItem, bool bEquipItem) { NativeCall<void, UPrimalItem*, bool>(this, "APrimalCharacter.NotifyItemAdded", anItem, bEquipItem); }
    void NotifyItemRemoved(UPrimalItem * anItem) { NativeCall<void, UPrimalItem*>(this, "APrimalCharacter.NotifyItemRemoved", anItem); }
    void TeleportSucceeded(bool bIsATest, bool bSimpleTeleport) { NativeCall<void, bool, bool>(this, "APrimalCharacter.TeleportSucceeded", bIsATest, bSimpleTeleport); }
    bool IsAttachedToSomething() { return NativeCall<bool>(this, "APrimalCharacter.IsAttachedToSomething"); }
    void AttachToOtherCharacter(APrimalCharacter * characterToAttachTo, FName InSocketName, const bool enableMovementAndCollision, EAttachLocation::Type AttachLocation) { NativeCall<void, APrimalCharacter*, FName, const bool, EAttachLocation::Type>(this, "APrimalCharacter.AttachToOtherCharacter", characterToAttachTo, InSocketName, enableMovementAndCollision, AttachLocation); }
    void AttachedToOtherCharacterUpdateWorldLocation(FVector * worldLocation) { NativeCall<void, FVector*>(this, "APrimalCharacter.AttachedToOtherCharacterUpdateWorldLocation", worldLocation); }
    void DetachFromOtherCharacter(const bool enableMovementAndCollision) { NativeCall<void, const bool>(this, "APrimalCharacter.DetachFromOtherCharacter", enableMovementAndCollision); }
    bool UseFastTurretTargeting() { return NativeCall<bool>(this, "APrimalCharacter.UseFastTurretTargeting"); }
    bool ConsumeProjectileImpact(AShooterProjectile * theProjectile, FHitResult * HitResult) { return NativeCall<bool, AShooterProjectile*, FHitResult*>(this, "APrimalCharacter.ConsumeProjectileImpact", theProjectile, HitResult); }
    bool IsProneOrSitting(bool bIgnoreLockedToSeat) { return NativeCall<bool, bool>(this, "APrimalCharacter.IsProneOrSitting", bIgnoreLockedToSeat); }
    bool CharacterIsCarriedAsPassenger() { return NativeCall<bool>(this, "APrimalCharacter.CharacterIsCarriedAsPassenger"); }
    void DoCharacterDetachment(bool bIncludeRiding, bool bIncludeCarrying, APrimalBuff * BuffToIgnore) { NativeCall<void, bool, bool, APrimalBuff*>(this, "APrimalCharacter.DoCharacterDetachment", bIncludeRiding, bIncludeCarrying, BuffToIgnore); }
    bool IsCharacterHardAttached(bool bIgnoreRiding, bool bIgnoreCarried) { return NativeCall<bool, bool, bool>(this, "APrimalCharacter.IsCharacterHardAttached", bIgnoreRiding, bIgnoreCarried); }
    void InitializedAnimScriptInstance() { NativeCall<void>(this, "APrimalCharacter.InitializedAnimScriptInstance"); }
    bool ForceAddUnderwaterCharacterStatusValues() { return NativeCall<bool>(this, "APrimalCharacter.ForceAddUnderwaterCharacterStatusValues"); }
    bool ShouldForceCameraStyle(APrimalCharacter * ForViewTarget, ECameraStyle::Type * OutForcedCameraStyle) { return NativeCall<bool, APrimalCharacter*, ECameraStyle::Type*>(this, "APrimalCharacter.ShouldForceCameraStyle", ForViewTarget, OutForcedCameraStyle); }
    bool IsPrimalCharFriendly(APrimalCharacter * primalChar) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalCharacter.IsPrimalCharFriendly", primalChar); }
    bool IsHostileTo(APrimalCharacter * OtherCharacter) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalCharacter.IsHostileTo", OtherCharacter); }
    bool IsHostileOrAggressiveTo(APrimalCharacter * OtherCharacter) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalCharacter.IsHostileOrAggressiveTo", OtherCharacter); }
    bool ShouldDealDamageTo(APrimalCharacter * OtherCharacter, bool bAllowDamageToSelf, bool bAllowDamageToTribe, bool bAllowDamageToAlliedTribes) { return NativeCall<bool, APrimalCharacter*, bool, bool, bool>(this, "APrimalCharacter.ShouldDealDamageTo", OtherCharacter, bAllowDamageToSelf, bAllowDamageToTribe, bAllowDamageToAlliedTribes); }
    bool TeleportTo(FVector * DestLocation, FRotator * DestRotation, bool bIsATest, bool bNoCheck) { return NativeCall<bool, FVector*, FRotator*, bool, bool>(this, "APrimalCharacter.TeleportTo", DestLocation, DestRotation, bIsATest, bNoCheck); }
    UPrimitiveComponent * GetBasedMovementComponent() { return NativeCall<UPrimitiveComponent*>(this, "APrimalCharacter.GetBasedMovementComponent"); }
    FVector * GetCapsuleTopLocation(FVector * result) { return NativeCall<FVector*, FVector*>(this, "APrimalCharacter.GetCapsuleTopLocation", result); }
    FVector * GetCapsuleBottomLocation(FVector * result) { return NativeCall<FVector*, FVector*>(this, "APrimalCharacter.GetCapsuleBottomLocation", result); }
    void OnMassTeleportEvent(EMassTeleportState::Type EventState, APrimalCharacter * TeleportInitiatedByChar) { NativeCall<void, EMassTeleportState::Type, APrimalCharacter*>(this, "APrimalCharacter.OnMassTeleportEvent", EventState, TeleportInitiatedByChar); }
    bool GetAllAttachedChars(TArray<APrimalCharacter*> * AttachedCharsArray, const bool bIncludeSelf, const bool bIncludeBased, const bool bIncludePassengers, const bool bIncludeCarried) { return NativeCall<bool, TArray<APrimalCharacter*>*, const bool, const bool, const bool, const bool>(this, "APrimalCharacter.GetAllAttachedChars", AttachedCharsArray, bIncludeSelf, bIncludeBased, bIncludePassengers, bIncludeCarried); }
    bool GetAllAttachedCharsInternal(TSet<APrimalCharacter*,DefaultKeyFuncs<APrimalCharacter*,0>,FDefaultSetAllocator> * AttachedChars, APrimalCharacter * OriginalChar, const bool bIncludeBased, const bool bIncludePassengers, const bool bIncludeCarried) { return NativeCall<bool, TSet<APrimalCharacter*,DefaultKeyFuncs<APrimalCharacter*,0>,FDefaultSetAllocator>*, APrimalCharacter*, const bool, const bool, const bool>(this, "APrimalCharacter.GetAllAttachedCharsInternal", AttachedChars, OriginalChar, bIncludeBased, bIncludePassengers, bIncludeCarried); }
    bool ShouldForceDedicatedMovementTickEveryFrame() { return NativeCall<bool>(this, "APrimalCharacter.ShouldForceDedicatedMovementTickEveryFrame"); }
    float GetMoveAnimRate() { return NativeCall<float>(this, "APrimalCharacter.GetMoveAnimRate"); }
    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", OutOfWaterZ); }
    void OverrideCameraInterpSpeed(const float DefaultTPVCameraSpeedInterpMultiplier, const float DefaultTPVOffsetInterpSpeed, float* TPVCameraSpeedInterpMultiplier, float* TPVOffsetInterpSpeed) { NativeCall<void, const float, const float, float*, float*>(this, "APrimalCharacter.OverrideCameraInterpSpeed", DefaultTPVCameraSpeedInterpMultiplier, DefaultTPVOffsetInterpSpeed, TPVCameraSpeedInterpMultiplier, TPVOffsetInterpSpeed); }
    void NativeSimulateHair(TArray<FVector> * CurrentPos, TArray<FVector> * LastPos, TArray<FVector> * RestPos, TArray<FVector> * PivotPos, TArray<float> * RestDistance, FVector HairSocketLoc, FRotator HairSocketRot, FVector ChestSocketLoc, FRotator 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, FVector ShoulderLCollisionOffset, float ShoulderLCollisionRadius, FVector ShoulderRCollisionOffset, float ShoulderRCollisionRadius, FVector HeadHairCollisionOffset, float HeadHairCollisionRadius, FVector NeckHairCollisionOffset, float NeckHairCollisionRadius, float MaxDistanceToRestPos, FTransform LastHeadTransform, bool bPosAsPivot, bool bCollideMiddle, bool bCollideWithNeck) { NativeCall<void, TArray<FVector>*, TArray<FVector>*, TArray<FVector>*, TArray<FVector>*, TArray<float>*, FVector, FRotator, FVector, FRotator, float, float, float, float, float, float, float, float, float, float, float, float, FVector, float, FVector, float, FVector, float, FVector, float, float, FTransform, bool, bool, bool>(this, "APrimalCharacter.NativeSimulateHair", 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 IsPrimalCharWalking() { return NativeCall<bool>(this, "APrimalCharacter.IsPrimalCharWalking"); }
    bool IsPrimalCharFalling() { return NativeCall<bool>(this, "APrimalCharacter.IsPrimalCharFalling"); }
    bool IsPrimalCharSwimming() { return NativeCall<bool>(this, "APrimalCharacter.IsPrimalCharSwimming"); }
    bool IsPrimalCharFlying() { return NativeCall<bool>(this, "APrimalCharacter.IsPrimalCharFlying"); }
    UAnimMontage * GetPoopAnimation(bool bForcePoop) { return NativeCall<UAnimMontage*, bool>(this, "APrimalCharacter.GetPoopAnimation", bForcePoop); }
    float GetBaseDragWeight() { return NativeCall<float>(this, "APrimalCharacter.GetBaseDragWeight"); }
    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", IncomingDamage, TheDamageEvent, EventInstigator, DamageCauser, bIsPointDamage, PointHitInfo); }
    void PlayDyingGeneric(float KillingDamage, FDamageEvent DamageEvent, APawn * InstigatingPawn, AActor * DamageCauser) { NativeCall<void, float, FDamageEvent, APawn*, AActor*>(this, "APrimalCharacter.PlayDyingGeneric", KillingDamage, DamageEvent, InstigatingPawn, DamageCauser); }
    void PlayDyingPoint(float KillingDamage, FPointDamageEvent DamageEvent, APawn * InstigatingPawn, AActor * DamageCauser) { NativeCall<void, float, FPointDamageEvent, APawn*, AActor*>(this, "APrimalCharacter.PlayDyingPoint", KillingDamage, DamageEvent, InstigatingPawn, DamageCauser); }
    void PlayDyingRadial(float KillingDamage, FRadialDamageEvent DamageEvent, APawn * InstigatingPawn, AActor * DamageCauser) { NativeCall<void, float, FRadialDamageEvent, APawn*, AActor*>(this, "APrimalCharacter.PlayDyingRadial", KillingDamage, DamageEvent, InstigatingPawn, DamageCauser); }
    void PlayHitEffectPoint(float DamageTaken, FPointDamageEvent DamageEvent, APawn * PawnInstigator, AActor * DamageCauser) { NativeCall<void, float, FPointDamageEvent, APawn*, AActor*>(this, "APrimalCharacter.PlayHitEffectPoint", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }
    void PlayHitEffectRadial(float DamageTaken, FRadialDamageEvent DamageEvent, APawn * PawnInstigator, AActor * DamageCauser) { NativeCall<void, float, FRadialDamageEvent, APawn*, AActor*>(this, "APrimalCharacter.PlayHitEffectRadial", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }
    bool BPPreventStasis() { return NativeCall<bool>(this, "APrimalCharacter.BPPreventStasis"); }
    FVector * BPAdjustCharacterMovementImpulse(FVector * result, FVector Impulse, bool bVelocityChange, float MassScaleImpulseExponent, bool bOverrideMaxImpulseZ) { return NativeCall<FVector*, FVector*, FVector, bool, float, bool>(this, "APrimalCharacter.BPAdjustCharacterMovementImpulse", result, Impulse, bVelocityChange, MassScaleImpulseExponent, bOverrideMaxImpulseZ); }
    FVector * BPAdjustImpulseFromDamage(FVector * result, FVector DesiredImpulse, float DamageTaken, FDamageEvent TheDamageEvent, APawn * PawnInstigator, AActor * DamageCauser, bool bIsPointDamage, FHitResult PointHitInfo) { return NativeCall<FVector*, FVector*, FVector, float, FDamageEvent, APawn*, AActor*, bool, FHitResult>(this, "APrimalCharacter.BPAdjustImpulseFromDamage", result, DesiredImpulse, DamageTaken, TheDamageEvent, PawnInstigator, DamageCauser, bIsPointDamage, PointHitInfo); }
    void BPCharacterDetach() { NativeCall<void>(this, "APrimalCharacter.BPCharacterDetach"); }
    ECameraStyle::Type BPForceCameraStyle(APrimalCharacter * ForViewTarget) { return NativeCall<ECameraStyle::Type, APrimalCharacter*>(this, "APrimalCharacter.BPForceCameraStyle", ForViewTarget); }
    FVector * BPOverrideCharacterNewFallVelocity(FVector * result, FVector * InitialVelocity, FVector * Gravity, float DeltaTime) { return NativeCall<FVector*, FVector*, FVector*, FVector*, float>(this, "APrimalCharacter.BPOverrideCharacterNewFallVelocity", result, InitialVelocity, Gravity, DeltaTime); }
    static void StaticRegisterNativesAPrimalCharacter() { NativeCall<void>(nullptr, "APrimalCharacter.StaticRegisterNativesAPrimalCharacter"); }
    static UClass * GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "APrimalCharacter.GetPrivateStaticClass"); }
    bool AllowPlayMontage(UAnimMontage * AnimMontage) { return NativeCall<bool, UAnimMontage*>(this, "APrimalCharacter.AllowPlayMontage", AnimMontage); }
    bool BP_ForceAllowAddBuff(TSubclassOf<APrimalBuff> BuffClass) { return NativeCall<bool, TSubclassOf<APrimalBuff>>(this, "APrimalCharacter.BP_ForceAllowAddBuff", BuffClass); }
    bool BP_IsCharacterHardAttached(bool bIgnoreRiding, bool bIgnoreCarried) { return NativeCall<bool, bool, bool>(this, "APrimalCharacter.BP_IsCharacterHardAttached", bIgnoreRiding, bIgnoreCarried); }
    void BP_OnEndCarried(bool bFromDino, bool bCancelAnyCarryBuffs) { NativeCall<void, bool, bool>(this, "APrimalCharacter.BP_OnEndCarried", bFromDino, bCancelAnyCarryBuffs); }
    void BP_OnJumpPressed() { NativeCall<void>(this, "APrimalCharacter.BP_OnJumpPressed"); }
    void BP_OnJumpReleased() { NativeCall<void>(this, "APrimalCharacter.BP_OnJumpReleased"); }
    void BP_OnSetDeath() { NativeCall<void>(this, "APrimalCharacter.BP_OnSetDeath"); }
    void BP_OnSetRunning(bool bNewIsRunning) { NativeCall<void, bool>(this, "APrimalCharacter.BP_OnSetRunning", bNewIsRunning); }
    void BP_OnStartCarried(APrimalDinoCharacter * aDino) { NativeCall<void, APrimalDinoCharacter*>(this, "APrimalCharacter.BP_OnStartCarried", aDino); }
    void BP_OnZoomIn() { NativeCall<void>(this, "APrimalCharacter.BP_OnZoomIn"); }
    void BP_OnZoomOut() { NativeCall<void>(this, "APrimalCharacter.BP_OnZoomOut"); }
    bool BP_ShouldDisableCameraInterpolation() { return NativeCall<bool>(this, "APrimalCharacter.BP_ShouldDisableCameraInterpolation"); }
    void BPAddedAttachmentsForItem(UPrimalItem * anItem) { NativeCall<void, UPrimalItem*>(this, "APrimalCharacter.BPAddedAttachmentsForItem", anItem); }
    float BPAdjustTorpidityDamage(float DesiredTorpidityDamage, float HealthDamageAmount, TSubclassOf<UDamageType> DamageType) { return NativeCall<float, float, float, TSubclassOf<UDamageType>>(this, "APrimalCharacter.BPAdjustTorpidityDamage", DesiredTorpidityDamage, HealthDamageAmount, DamageType); }
    void BPApplyCharacterSnapshot(UPrimalItem * Item, AActor * To, FVector Offset, float MaxExtent, int Pose) { NativeCall<void, UPrimalItem*, AActor*, FVector, float, int>(this, "APrimalCharacter.BPApplyCharacterSnapshot", Item, To, Offset, MaxExtent, Pose); }
    FRotator * BPCameraBaseOrientation(FRotator * result, APrimalCharacter * viewingCharacter) { return NativeCall<FRotator*, FRotator*, APrimalCharacter*>(this, "APrimalCharacter.BPCameraBaseOrientation", result, viewingCharacter); }
    FRotator * BPCameraRotationFinal(FRotator * result, APrimalCharacter * viewingCharacter, FRotator * InCurrentFinalRot) { return NativeCall<FRotator*, FRotator*, APrimalCharacter*, FRotator*>(this, "APrimalCharacter.BPCameraRotationFinal", result, viewingCharacter, InCurrentFinalRot); }
    bool BPCanBaseOnCharacter(APrimalCharacter * BaseCharacter) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalCharacter.BPCanBaseOnCharacter", BaseCharacter); }
    bool BPCanBeBaseForCharacter(APawn * Pawn) { return NativeCall<bool, APawn*>(this, "APrimalCharacter.BPCanBeBaseForCharacter", Pawn); }
    bool BPCanNotifyTeamAggroAI(APrimalDinoCharacter * Dino) { return NativeCall<bool, APrimalDinoCharacter*>(this, "APrimalCharacter.BPCanNotifyTeamAggroAI", Dino); }
    void BPCharacterSleeped() { NativeCall<void>(this, "APrimalCharacter.BPCharacterSleeped"); }
    void BPCharacterUnsleeped() { NativeCall<void>(this, "APrimalCharacter.BPCharacterUnsleeped"); }
    void BPCheckJumpInput(bool* bUseCustomErrorMessage, FString * ErrorMessageToDisplay) { NativeCall<void, bool*, FString*>(this, "APrimalCharacter.BPCheckJumpInput", bUseCustomErrorMessage, ErrorMessageToDisplay); }
    float BPGetAddForwardVelocityOnJump() { return NativeCall<float>(this, "APrimalCharacter.BPGetAddForwardVelocityOnJump"); }
    float BPGetExtraMeleeDamageModifier() { return NativeCall<float>(this, "APrimalCharacter.BPGetExtraMeleeDamageModifier"); }
    FVector * BPGetFPVViewLocation(FVector * result, APrimalCharacter * viewingCharacter) { return NativeCall<FVector*, FVector*, APrimalCharacter*>(this, "APrimalCharacter.BPGetFPVViewLocation", result, viewingCharacter); }
    float BPGetGravityZScale() { return NativeCall<float>(this, "APrimalCharacter.BPGetGravityZScale"); }
    float BPGetHUDOverrideBuffProgressBarPercent() { return NativeCall<float>(this, "APrimalCharacter.BPGetHUDOverrideBuffProgressBarPercent"); }
    void BPGetOverrideCameraInterpSpeed(float DefaultTPVCameraSpeedInterpolationMultiplier, float DefaultTPVOffsetInterpSpeed, float* TPVCameraSpeedInterpolationMultiplier, float* TPVOffsetInterpSpeed) { NativeCall<void, float, float, float*, float*>(this, "APrimalCharacter.BPGetOverrideCameraInterpSpeed", DefaultTPVCameraSpeedInterpolationMultiplier, DefaultTPVOffsetInterpSpeed, TPVCameraSpeedInterpolationMultiplier, TPVOffsetInterpSpeed); }
    bool BPHandleLeftShoulderButton() { return NativeCall<bool>(this, "APrimalCharacter.BPHandleLeftShoulderButton"); }
    bool BPHandlePoop() { return NativeCall<bool>(this, "APrimalCharacter.BPHandlePoop"); }
    bool BPHandleRightShoulderButton() { return NativeCall<bool>(this, "APrimalCharacter.BPHandleRightShoulderButton"); }
    FRotator * BPLimitPlayerRotation(FRotator * result, APrimalCharacter * viewingCharacter, FRotator InViewRotation) { return NativeCall<FRotator*, FRotator*, APrimalCharacter*, FRotator>(this, "APrimalCharacter.BPLimitPlayerRotation", result, viewingCharacter, InViewRotation); }
    FVector * BPModifyForwardDirectionInput(FVector * result, FVector * directionInput) { return NativeCall<FVector*, FVector*, FVector*>(this, "APrimalCharacter.BPModifyForwardDirectionInput", result, directionInput); }
    float BPModifyFOVInterpSpeed(float FOVInterpSpeedIn) { return NativeCall<float, float>(this, "APrimalCharacter.BPModifyFOVInterpSpeed", FOVInterpSpeedIn); }
    FVector * BPModifyRightDirectionInput(FVector * result, FVector * directionInput) { return NativeCall<FVector*, FVector*, FVector*>(this, "APrimalCharacter.BPModifyRightDirectionInput", result, directionInput); }
    float BPModifyViewHitDir(APrimalCharacter * viewingCharacter, float InViewHitDir) { return NativeCall<float, APrimalCharacter*, float>(this, "APrimalCharacter.BPModifyViewHitDir", viewingCharacter, InViewHitDir); }
    void BPNotifyBPNotifyIsDamageCauserOfAddedBuff(APrimalBuff * buff) { NativeCall<void, APrimalBuff*>(this, "APrimalCharacter.BPNotifyBPNotifyIsDamageCauserOfAddedBuff", buff); }
    void BPNotifyBumpedByPawn(APrimalCharacter * ByPawn) { NativeCall<void, APrimalCharacter*>(this, "APrimalCharacter.BPNotifyBumpedByPawn", ByPawn); }
    void BPNotifyBumpedPawn(APrimalCharacter * BumpedPawn) { NativeCall<void, APrimalCharacter*>(this, "APrimalCharacter.BPNotifyBumpedPawn", BumpedPawn); }
    void BPNotifyDroppedItemPickedUp(ADroppedItem * itemPickedUp, APrimalCharacter * PickedUpBy) { NativeCall<void, ADroppedItem*, APrimalCharacter*>(this, "APrimalCharacter.BPNotifyDroppedItemPickedUp", itemPickedUp, PickedUpBy); }
    void BPNotifyLevelUp(int ExtraCharacterLevel) { NativeCall<void, int>(this, "APrimalCharacter.BPNotifyLevelUp", ExtraCharacterLevel); }
    void BPNotifyToggleHUD(bool bHUDHidden) { NativeCall<void, bool>(this, "APrimalCharacter.BPNotifyToggleHUD", bHUDHidden); }
    void BPOnAnimPlayedNotify(UAnimMontage * AnimMontage, float InPlayRate, FName StartSectionName, bool bReplicate, bool bReplicateToOwner, bool bForceTickPoseAndServerUpdateMesh, bool bForceTickPoseOnServer) { NativeCall<void, UAnimMontage*, float, FName, bool, bool, bool, bool>(this, "APrimalCharacter.BPOnAnimPlayedNotify", AnimMontage, InPlayRate, StartSectionName, bReplicate, bReplicateToOwner, bForceTickPoseAndServerUpdateMesh, bForceTickPoseOnServer); }
    bool BPOnAttachmentReplication() { return NativeCall<bool>(this, "APrimalCharacter.BPOnAttachmentReplication"); }
    void BPOnLethalDamage(float KillingDamage, FDamageEvent * DamageEvent, AController * Killer, AActor * DamageCauser, bool* bPreventDeath) { NativeCall<void, float, FDamageEvent*, AController*, AActor*, bool*>(this, "APrimalCharacter.BPOnLethalDamage", KillingDamage, DamageEvent, Killer, DamageCauser, bPreventDeath); }
    void BPOnMassTeleportEvent(EMassTeleportState::Type EventState, APrimalCharacter * TeleportInitiatedByChar) { NativeCall<void, EMassTeleportState::Type, APrimalCharacter*>(this, "APrimalCharacter.BPOnMassTeleportEvent", EventState, TeleportInitiatedByChar); }
    void BPOnMovementModeChangedNotify(EMovementMode PrevMovementMode, char PreviousCustomMode) { NativeCall<void, EMovementMode, char>(this, "APrimalCharacter.BPOnMovementModeChangedNotify", PrevMovementMode, PreviousCustomMode); }
    void BPOnStaminaDrained() { NativeCall<void>(this, "APrimalCharacter.BPOnStaminaDrained"); }
    FVector * BPOverrideFlyingVelocity(FVector * result, FVector * InitialVelocity, FVector * Gravity, float DeltaTime) { return NativeCall<FVector*, FVector*, FVector*, FVector*, float>(this, "APrimalCharacter.BPOverrideFlyingVelocity", result, InitialVelocity, Gravity, DeltaTime); }
    bool BPOverrideFPVViewLocation(APrimalCharacter * viewingCharacter) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalCharacter.BPOverrideFPVViewLocation", viewingCharacter); }
    UAnimMontage * BPOverrideHurtAnim(float DamageTaken, FDamageEvent * DamageEvent, APawn * PawnInstigator, AActor * DamageCauser, bool bIsLocalPath, bool bIsPointDamage, FVector PointDamageLocation, FVector PointDamageHitNormal) { return NativeCall<UAnimMontage*, float, FDamageEvent*, APawn*, AActor*, bool, bool, FVector, FVector>(this, "APrimalCharacter.BPOverrideHurtAnim", DamageTaken, DamageEvent, PawnInstigator, DamageCauser, bIsLocalPath, bIsPointDamage, PointDamageLocation, PointDamageHitNormal); }
    void BPPreSerializeSaveGame() { NativeCall<void>(this, "APrimalCharacter.BPPreSerializeSaveGame"); }
    bool BPPreventFallDamage(FHitResult * HitResult, float FallDamageAmount) { return NativeCall<bool, FHitResult*, float>(this, "APrimalCharacter.BPPreventFallDamage", HitResult, FallDamageAmount); }
    bool BPPreventInputType(EPrimalCharacterInputType::Type inputType) { return NativeCall<bool, EPrimalCharacterInputType::Type>(this, "APrimalCharacter.BPPreventInputType", inputType); }
    void BPRemoveCharacterSnapshot(UPrimalItem * Item, AActor * From) { NativeCall<void, UPrimalItem*, AActor*>(this, "APrimalCharacter.BPRemoveCharacterSnapshot", Item, From); }
    void BPSetCharacterMeshesMaterialScalarParamValue(FName ParamName, float Value) { NativeCall<void, FName, float>(this, "APrimalCharacter.BPSetCharacterMeshesMaterialScalarParamValue", ParamName, Value); }
    bool BPShouldLimitForwardDirection() { return NativeCall<bool>(this, "APrimalCharacter.BPShouldLimitForwardDirection"); }
    bool BPShouldLimitRightDirection() { return NativeCall<bool>(this, "APrimalCharacter.BPShouldLimitRightDirection"); }
    void BPTimerNonDedicated() { NativeCall<void>(this, "APrimalCharacter.BPTimerNonDedicated"); }
    void BPTimerServer() { NativeCall<void>(this, "APrimalCharacter.BPTimerServer"); }
    void ClientDidPoop() { NativeCall<void>(this, "APrimalCharacter.ClientDidPoop"); }
    void ClientEndRagdollUpdate() { NativeCall<void>(this, "APrimalCharacter.ClientEndRagdollUpdate"); }
    void ClientFailedPoop() { NativeCall<void>(this, "APrimalCharacter.ClientFailedPoop"); }
    void ClientNotifyLevelUp() { NativeCall<void>(this, "APrimalCharacter.ClientNotifyLevelUp"); }
    void ClientPlayAnimation(UAnimMontage * AnimMontage, float PlayRate, FName StartSectionName, bool bPlayOnOwner, bool bForceTickPoseAndServerUpdateMesh) { NativeCall<void, UAnimMontage*, float, FName, bool, bool>(this, "APrimalCharacter.ClientPlayAnimation", AnimMontage, PlayRate, StartSectionName, bPlayOnOwner, bForceTickPoseAndServerUpdateMesh); }
    void ClientRagdollUpdate(TArray<FVector_NetQuantize> * BoneLocations, FRotator_NetQuantize TargetRootRotation) { NativeCall<void, TArray<FVector_NetQuantize>*, FRotator_NetQuantize>(this, "APrimalCharacter.ClientRagdollUpdate", BoneLocations, TargetRootRotation); }
    void ClientStopAnimation(UAnimMontage * AnimMontage, bool bStopOnOwner, float BlendOutTime) { NativeCall<void, UAnimMontage*, bool, float>(this, "APrimalCharacter.ClientStopAnimation", AnimMontage, bStopOnOwner, BlendOutTime); }
    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", AnimMontage, PlayRate, ServerCurrentMontageTime, bForceTickPoseAndServerUpdateMesh, BlendInTime, BlendOutTime); }
    void DeathHarvestingFadeOut() { NativeCall<void>(this, "APrimalCharacter.DeathHarvestingFadeOut"); }
    void DidTeleport(FVector newLoc, FRotator newRot) { NativeCall<void, FVector, FRotator>(this, "APrimalCharacter.DidTeleport", newLoc, newRot); }
    bool EnableTurnToFaceRotation() { return NativeCall<bool>(this, "APrimalCharacter.EnableTurnToFaceRotation"); }
    TSubclassOf<APrimalBuff_Grappled> * GetGrappledBuffClassOverride(TSubclassOf<APrimalBuff_Grappled> * result) { return NativeCall<TSubclassOf<APrimalBuff_Grappled>*, TSubclassOf<APrimalBuff_Grappled>*>(this, "APrimalCharacter.GetGrappledBuffClassOverride", result); }
    FName * GetOverrideSocket(FName * result, FName from) { return NativeCall<FName*, FName*, FName>(this, "APrimalCharacter.GetOverrideSocket", result, from); }
    bool GiveKillExperience() { return NativeCall<bool>(this, "APrimalCharacter.GiveKillExperience"); }
    void LocalUnpossessed() { NativeCall<void>(this, "APrimalCharacter.LocalUnpossessed"); }
    void NetAddCharacterMovementImpulse(FVector Impulse, bool bVelChange, float ImpulseExponent, bool bSetNewMovementMode, EMovementMode NewMovementMode, bool bOverrideMaxImpulseZ) { NativeCall<void, FVector, bool, float, bool, EMovementMode, bool>(this, "APrimalCharacter.NetAddCharacterMovementImpulse", Impulse, bVelChange, ImpulseExponent, bSetNewMovementMode, NewMovementMode, bOverrideMaxImpulseZ); }
    void NetDidLand() { NativeCall<void>(this, "APrimalCharacter.NetDidLand"); }
    void NetOnJumped() { NativeCall<void>(this, "APrimalCharacter.NetOnJumped"); }
    void NetPlaySoundOnCharacter(USoundBase * SoundToPlay, bool bPlayOnOwner) { NativeCall<void, USoundBase*, bool>(this, "APrimalCharacter.NetPlaySoundOnCharacter", SoundToPlay, bPlayOnOwner); }
    void NetSetCharacterMovementVelocity(bool bSetNewVelocity, FVector NewVelocity, bool bSetNewMovementMode, EMovementMode NewMovementMode) { NativeCall<void, bool, FVector, bool, EMovementMode>(this, "APrimalCharacter.NetSetCharacterMovementVelocity", bSetNewVelocity, NewVelocity, bSetNewMovementMode, NewMovementMode); }
    void NetStopAllAnimMontage() { NativeCall<void>(this, "APrimalCharacter.NetStopAllAnimMontage"); }
    void NetUpdateTribeName(FString * NewTribeName) { NativeCall<void, FString*>(this, "APrimalCharacter.NetUpdateTribeName", NewTribeName); }
    void OnBeginDrag(APrimalCharacter * Dragged, int BoneIndex, bool bWithGrapHook) { NativeCall<void, APrimalCharacter*, int, bool>(this, "APrimalCharacter.OnBeginDrag", Dragged, BoneIndex, bWithGrapHook); }
    void OnEndDrag() { NativeCall<void>(this, "APrimalCharacter.OnEndDrag"); }
    bool PreventsTargeting(AActor * ByActor) { return NativeCall<bool, AActor*>(this, "APrimalCharacter.PreventsTargeting", ByActor); }
    void ServerCallAggressive() { NativeCall<void>(this, "APrimalCharacter.ServerCallAggressive"); }
    void ServerCallAttackTarget(AActor * TheTarget) { NativeCall<void, AActor*>(this, "APrimalCharacter.ServerCallAttackTarget", TheTarget); }
    void ServerCallFollow() { NativeCall<void>(this, "APrimalCharacter.ServerCallFollow"); }
    void ServerCallFollowDistanceCycleOne(APrimalDinoCharacter * ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "APrimalCharacter.ServerCallFollowDistanceCycleOne", ForDinoChar); }
    void ServerCallFollowOne(APrimalDinoCharacter * ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "APrimalCharacter.ServerCallFollowOne", ForDinoChar); }
    void ServerCallLandFlyerOne(APrimalDinoCharacter * ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "APrimalCharacter.ServerCallLandFlyerOne", ForDinoChar); }
    void ServerCallMoveTo(FVector MoveToLoc) { NativeCall<void, FVector>(this, "APrimalCharacter.ServerCallMoveTo", 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 ServerCallStayOne(APrimalDinoCharacter * ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "APrimalCharacter.ServerCallStayOne", ForDinoChar); }
    void ServerCaptureDermis(APrimalCharacter * Target) { NativeCall<void, APrimalCharacter*>(this, "APrimalCharacter.ServerCaptureDermis", Target); }
    void ServerDinoOrder(APrimalDinoCharacter * aDino, EDinoTamedOrder::Type OrderType, AActor * target) { NativeCall<void, APrimalDinoCharacter*, EDinoTamedOrder::Type, AActor*>(this, "APrimalCharacter.ServerDinoOrder", aDino, OrderType, target); }
    void ServerGiveDefaultWeapon() { NativeCall<void>(this, "APrimalCharacter.ServerGiveDefaultWeapon"); }
    void ServerRequestDrag() { NativeCall<void>(this, "APrimalCharacter.ServerRequestDrag"); }
    void ServerSetRunning(bool bNewRunning) { NativeCall<void, bool>(this, "APrimalCharacter.ServerSetRunning", bNewRunning); }
    void ServerTryPoop() { NativeCall<void>(this, "APrimalCharacter.ServerTryPoop"); }
};
 
struct AShooterCharacter : APrimalCharacter
{
    TArray<FTransponderInfo>& ClientTranspondersInfoField() { return *GetNativePointerField<TArray<FTransponderInfo>*>(this, "AShooterCharacter.ClientTranspondersInfo"); }
    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"); }
    UAnimMontage* VoiceYellingAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.VoiceYellingAnim"); }
    TArray<UAnimMontage*> EmoteAnimsField() { return *GetNativePointerField<TArray<UAnimMontage*>*>(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"); }
    FString& VivoxUsernameField() { return *GetNativePointerField<FString*>(this, "AShooterCharacter.VivoxUsername"); }
    unsigned int& CurrentVoiceModeAsUInt32Field() { return *GetNativePointerField<unsigned int*>(this, "AShooterCharacter.CurrentVoiceModeAsUInt32"); }
    unsigned int& VoiceModeForCullingTestsField() { return *GetNativePointerField<unsigned int*>(this, "AShooterCharacter.VoiceModeForCullingTests"); }
    bool& bIsActivelyTalkingField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bIsActivelyTalking"); }
    bool& bClientIgnoreCurrentVoiceModeReplicationsField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bClientIgnoreCurrentVoiceModeReplications"); }
    bool& bWasAlreadyYellingField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bWasAlreadyYelling"); }
    bool& bWasProneField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bWasProne"); }
    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& TargetingTimeField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.TargetingTime"); }
    float& BobMaxMovementSpeedField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.BobMaxMovementSpeed"); }
    float& WeaponBobMaxMovementSpeedField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.WeaponBobMaxMovementSpeed"); }
    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"); }
    FVector& LastCheckSevenLocationField() { return *GetNativePointerField<FVector*>(this, "AShooterCharacter.LastCheckSevenLocation"); }
    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"); }
    TArray<FName>& LowerBodyPartRootBonesField() { return *GetNativePointerField<TArray<FName>*>(this, "AShooterCharacter.LowerBodyPartRootBones"); }
    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"); }
    FRotator& LastDinoAimRotationOffsetField() { return *GetNativePointerField<FRotator*>(this, "AShooterCharacter.LastDinoAimRotationOffset"); }
    FRotator& LastAimRotOffsetField() { return *GetNativePointerField<FRotator*>(this, "AShooterCharacter.LastAimRotOffset"); }
    APrimalProjectileBoomerang* LastFiredBoomerangField() { return *GetNativePointerField<APrimalProjectileBoomerang**>(this, "AShooterCharacter.LastFiredBoomerang"); }
    UAudioComponent* LastGrapHookACField() { return *GetNativePointerField<UAudioComponent**>(this, "AShooterCharacter.LastGrapHookAC"); }
    int& _GrapHookCableObjectCountField() { return *GetNativePointerField<int*>(this, "AShooterCharacter._GrapHookCableObjectCount"); }
    FVector& GrapHookDefaultOffsetField() { return *GetNativePointerField<FVector*>(this, "AShooterCharacter.GrapHookDefaultOffset"); }
    float& GrapHookCableWidthField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.GrapHookCableWidth"); }
    UMaterialInterface* GrapHookMaterialField() { return *GetNativePointerField<UMaterialInterface**>(this, "AShooterCharacter.GrapHookMaterial"); }
    float& LadderLateralJumpVelocityField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.LadderLateralJumpVelocity"); }
    float& GrapHookPulledRopeDistanceField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.GrapHookPulledRopeDistance"); }
    float& GrapHookSyncTimeField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.GrapHookSyncTime"); }
    bool& bReleasingGrapHookField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bReleasingGrapHook"); }
    FString& PlatformProfileNameField() { return *GetNativePointerField<FString*>(this, "AShooterCharacter.PlatformProfileName"); }
    FUniqueNetIdRepl& PlatformProfileIDField() { return *GetNativePointerField<FUniqueNetIdRepl*>(this, "AShooterCharacter.PlatformProfileID"); }
    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"); }
    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"); }
    FName& WeaponAttachPointField() { return *GetNativePointerField<FName*>(this, "AShooterCharacter.WeaponAttachPoint"); }
    float& TargetingSpeedModifierField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.TargetingSpeedModifier"); }
    USoundCue* LowHealthSoundField() { return *GetNativePointerField<USoundCue**>(this, "AShooterCharacter.LowHealthSound"); }
    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"); }
    long double& PressCrouchProneToggleTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.PressCrouchProneToggleTime"); }
    float& CraftingMovementSpeedModifierField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.CraftingMovementSpeedModifier"); }
    FVector& WeaponBobMagnitudesField() { return *GetNativePointerField<FVector*>(this, "AShooterCharacter.WeaponBobMagnitudes"); }
    FVector& WeaponBobPeriodsField() { return *GetNativePointerField<FVector*>(this, "AShooterCharacter.WeaponBobPeriods"); }
    FVector& WeaponBobOffsetsField() { return *GetNativePointerField<FVector*>(this, "AShooterCharacter.WeaponBobOffsets"); }
    FVector& WeaponBobMagnitudes_TargetingField() { return *GetNativePointerField<FVector*>(this, "AShooterCharacter.WeaponBobMagnitudes_Targeting"); }
    FVector& WeaponBobPeriods_TargetingField() { return *GetNativePointerField<FVector*>(this, "AShooterCharacter.WeaponBobPeriods_Targeting"); }
    FVector& WeaponBobOffsets_TargetingField() { return *GetNativePointerField<FVector*>(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>& DefaultAttachmentInfosField() { return *GetNativePointerField<TArray<FItemAttachmentInfo>*>(this, "AShooterCharacter.DefaultAttachmentInfos"); }
    USoundCue* StartCrouchSoundField() { return *GetNativePointerField<USoundCue**>(this, "AShooterCharacter.StartCrouchSound"); }
    USoundCue* EndCrouchSoundField() { return *GetNativePointerField<USoundCue**>(this, "AShooterCharacter.EndCrouchSound"); }
    USoundCue* StartProneSoundField() { return *GetNativePointerField<USoundCue**>(this, "AShooterCharacter.StartProneSound"); }
    USoundCue* EndProneSoundField() { return *GetNativePointerField<USoundCue**>(this, "AShooterCharacter.EndProneSound"); }
    TSubclassOf<AShooterWeapon>& NextInventoryWeaponField() { return *GetNativePointerField<TSubclassOf<AShooterWeapon>*>(this, "AShooterCharacter.NextInventoryWeapon"); }
    FItemNetID& PreMapWeaponItemNetIDField() { return *GetNativePointerField<FItemNetID*>(this, "AShooterCharacter.PreMapWeaponItemNetID"); }
    float& ServerSeatedViewRotationYawField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.ServerSeatedViewRotationYaw"); }
    float& ServerSeatedViewRotationPitchField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.ServerSeatedViewRotationPitch"); }
    AShooterWeapon* CurrentWeaponField() { return *GetNativePointerField<AShooterWeapon**>(this, "AShooterCharacter.CurrentWeapon"); }
    unsigned __int64& LinkedPlayerDataIDField() { return *GetNativePointerField<unsigned __int64*>(this, "AShooterCharacter.LinkedPlayerDataID"); }
    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"); }
    unsigned __int64& LastRequestedTribeIDField() { return *GetNativePointerField<unsigned __int64*>(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"); }
    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"); }
    FSaddlePassengerSeatDefinition& CurrentPassengerSeatDefinitionField() { return *GetNativePointerField<FSaddlePassengerSeatDefinition*>(this, "AShooterCharacter.CurrentPassengerSeatDefinition"); }
    TArray<UAnimMontage*> AnimsOverrideFromField() { return *GetNativePointerField<TArray<UAnimMontage*>*>(this, "AShooterCharacter.AnimsOverrideFrom"); }
    TArray<UAnimMontage*> AnimOverrideToField() { return *GetNativePointerField<TArray<UAnimMontage*>*>(this, "AShooterCharacter.AnimOverrideTo"); }
    TArray<UAnimSequence*> AnimSequencesOverrideFromField() { return *GetNativePointerField<TArray<UAnimSequence*>*>(this, "AShooterCharacter.AnimSequencesOverrideFrom"); }
    TArray<UAnimSequence*> AnimSequenceOverrideToField() { return *GetNativePointerField<TArray<UAnimSequence*>*>(this, "AShooterCharacter.AnimSequenceOverrideTo"); }
    float& PreviousRootYawSpeedField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.PreviousRootYawSpeed"); }
    FieldArray<FLinearColor, 4> BodyColorsField() { return { this, "AShooterCharacter.BodyColors" }; }
    char& FacialHairIndexField() { return *GetNativePointerField<char*>(this, "AShooterCharacter.FacialHairIndex"); }
    char& HeadHairIndexField() { return *GetNativePointerField<char*>(this, "AShooterCharacter.HeadHairIndex"); }
    FieldArray<float, 22> RawBoneModifiersField() { return { this, "AShooterCharacter.RawBoneModifiers" }; }
    float& LoggedOutTargetingDesirabilityField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.LoggedOutTargetingDesirability"); }
    bool& bIsRainWateredField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bIsRainWatered"); }
    long double& LastAttackTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastAttackTime"); }
    bool& bCacheRidingDinoWeaponField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bCacheRidingDinoWeapon"); }
    bool& bWasLocallyControlledField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bWasLocallyControlled"); }
    unsigned int& UniqueNetIdTypeHashField() { return *GetNativePointerField<unsigned int*>(this, "AShooterCharacter.UniqueNetIdTypeHash"); }
    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"); }
    long double& LocalLastViewingInventoryTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LocalLastViewingInventoryTime"); }
    FVector& LastStasisCastPositionField() { return *GetNativePointerField<FVector*>(this, "AShooterCharacter.LastStasisCastPosition"); }
    bool& bWasHostPlayerField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bWasHostPlayer"); }
    long double& SavedLastTimeHadControllerField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.SavedLastTimeHadController"); }
    long double& LastTimeHadControllerField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastTimeHadController"); }
    long double& LastTaggedTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastTaggedTime"); }
    long double& LastTaggedTimeExtraField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastTaggedTimeExtra"); }
    long double& LastTaggedTimeThirdField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastTaggedTimeThird"); }
    float& ExtraFloatVarField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.ExtraFloatVar"); }
    FVector& ExtraVectorVarField() { return *GetNativePointerField<FVector*>(this, "AShooterCharacter.ExtraVectorVar"); }
    FVector& ExtraExtraVectorVarField() { return *GetNativePointerField<FVector*>(this, "AShooterCharacter.ExtraExtraVectorVar"); }
    FName& ExtraNameVarField() { return *GetNativePointerField<FName*>(this, "AShooterCharacter.ExtraNameVar"); }
    bool& bIsOnSeatingStructureField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bIsOnSeatingStructure"); }
    bool& bIsControllingBallistaField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bIsControllingBallista"); }
    bool& bUseBallistaAimOffsetField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bUseBallistaAimOffset"); }
    float& CurrentControlledBallistaYawField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.CurrentControlledBallistaYaw"); }
    bool& bIsServerAdminField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bIsServerAdmin"); }
    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"); }
    char& PlayerBadgeGroupField() { return *GetNativePointerField<char*>(this, "AShooterCharacter.PlayerBadgeGroup"); }
    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"); }
    FVector& UpdateHyperThermalInsulationPositionField() { return *GetNativePointerField<FVector*>(this, "AShooterCharacter.UpdateHyperThermalInsulationPosition"); }
    FVector& UpdateHypoThermalInsulationPositionField() { return *GetNativePointerField<FVector*>(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"); }
    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"); }
    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& 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"); }
    FVector& OriginalLastHitWallSweepCheckLocationField() { return *GetNativePointerField<FVector*>(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"); }
    bool& bPreventWeaponMovementAnimsField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bPreventWeaponMovementAnims"); }
    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"); }
    int& PlayerHexagonCountField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.PlayerHexagonCount"); }
    int& DefaultHexagonAmountEarnedOnMissionCompletionField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.DefaultHexagonAmountEarnedOnMissionCompletion"); }
    bool& bAutoPlayerField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bAutoPlayer"); }
    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& bAutoJumpField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bAutoJump"); }
    bool& bAutoFireField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bAutoFire"); }
    bool& bAutoFireTargetField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bAutoFireTarget"); }
    bool& bAutoProneField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bAutoProne"); }
    float& MeshHeightAdjustmentField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.MeshHeightAdjustment"); }
    float& BuffExtraDamageMultiplierField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.BuffExtraDamageMultiplier"); }
 
    // Bit fields
 
    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> 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> bWasOverrideHiddenShadowValue() { return { this, "AShooterCharacter.bWasOverrideHiddenShadowValue" }; }
    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> bLockedToSeatingStructure() { return { this, "AShooterCharacter.bLockedToSeatingStructure" }; }
    BitFieldValue<bool, unsigned __int32> bPreventAllWeapons() { return { this, "AShooterCharacter.bPreventAllWeapons" }; }
 
    // Functions
 
    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "AShooterCharacter.GetPrivateStaticClass"); }
    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "AShooterCharacter.StaticClass"); }
    bool TemplateAllowActorSpawn(UWorld* World, FVector* AtLocation, FRotator* AtRotation, FActorSpawnParameters* SpawnParameters) { return NativeCall<bool, UWorld*, FVector*, FRotator*, FActorSpawnParameters*>(this, "AShooterCharacter.TemplateAllowActorSpawn", World, AtLocation, AtRotation, SpawnParameters); }
    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 UpdateTransponders() { NativeCall<void>(this, "AShooterCharacter.UpdateTransponders"); }
    void BeginPlay() { NativeCall<void>(this, "AShooterCharacter.BeginPlay"); }
    FVector* GetTPVCameraOffset(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AShooterCharacter.GetTPVCameraOffset", result); }
    void DrawTranspondersInfo(AShooterHUD* HUD) { NativeCall<void, AShooterHUD*>(this, "AShooterCharacter.DrawTranspondersInfo", HUD); }
    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", theController); }
    void ModifyFirstPersonCameraLocation(FVector* Loc, float DeltaTime) { NativeCall<void, FVector*, float>(this, "AShooterCharacter.ModifyFirstPersonCameraLocation", Loc, DeltaTime); }
    void PossessedBy(AController* InController) { NativeCall<void, AController*>(this, "AShooterCharacter.PossessedBy", InController); }
    void LocalPossessedBy(APlayerController* ByController) { NativeCall<void, APlayerController*>(this, "AShooterCharacter.LocalPossessedBy", ByController); }
    void ServerDetachGrapHookCable_Implementation(bool bDoUpwardsJump, float UpwardsJumpYaw) { NativeCall<void, bool, float>(this, "AShooterCharacter.ServerDetachGrapHookCable_Implementation", bDoUpwardsJump, UpwardsJumpYaw); }
    void ServerReleaseGrapHookCable_Implementation(bool bReleasing) { NativeCall<void, bool>(this, "AShooterCharacter.ServerReleaseGrapHookCable_Implementation", bReleasing); }
    void DetachGrapHookCable_Implementation() { NativeCall<void>(this, "AShooterCharacter.DetachGrapHookCable_Implementation"); }
    void SyncGrapHookDistance_Implementation(float Distance) { NativeCall<void, float>(this, "AShooterCharacter.SyncGrapHookDistance_Implementation", Distance); }
    void UpdateGrapHook(float DeltaSeconds) { NativeCall<void, float>(this, "AShooterCharacter.UpdateGrapHook", DeltaSeconds); }
    void SetCarriedPitchYaw_Implementation(float NewCarriedPitch, float NewCarriedYaw) { NativeCall<void, float, float>(this, "AShooterCharacter.SetCarriedPitchYaw_Implementation", NewCarriedPitch, NewCarriedYaw); }
    FRotator* GetAimOffsets(FRotator* result, float DeltaTime, FRotator* RootRotOffset, float* RootYawSpeed, float MaxYawAimClamp, FVector* RootLocOffset) { return NativeCall<FRotator*, FRotator*, float, FRotator*, float*, float, FVector*>(this, "AShooterCharacter.GetAimOffsets", result, DeltaTime, RootRotOffset, RootYawSpeed, MaxYawAimClamp, RootLocOffset); }
    void UpdatePawnMeshes(bool bForceThirdPerson, bool bForceFlush) { NativeCall<void, bool, bool>(this, "AShooterCharacter.UpdatePawnMeshes", bForceThirdPerson, bForceFlush); }
    void OnCameraUpdate(FVector* CameraLocation, FRotator* CameraRotation) { NativeCall<void, FVector*, FRotator*>(this, "AShooterCharacter.OnCameraUpdate", CameraLocation, CameraRotation); }
    TSubclassOf<AShooterWeapon>* GetDefaultWeapon(TSubclassOf<AShooterWeapon>* result) { return NativeCall<TSubclassOf<AShooterWeapon>*, TSubclassOf<AShooterWeapon>*>(this, "AShooterCharacter.GetDefaultWeapon", result); }
    void ToggleWeapon() { NativeCall<void>(this, "AShooterCharacter.ToggleWeapon"); }
    void GiveDefaultWeapon(bool bForceGiveDefaultWeapon) { NativeCall<void, bool>(this, "AShooterCharacter.GiveDefaultWeapon", bForceGiveDefaultWeapon); }
    void GiveMapWeapon() { NativeCall<void>(this, "AShooterCharacter.GiveMapWeapon"); }
    void SwitchMap() { NativeCall<void>(this, "AShooterCharacter.SwitchMap"); }
    void DelayGiveDefaultWeapon(float DelayTime) { NativeCall<void, float>(this, "AShooterCharacter.DelayGiveDefaultWeapon", 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", aPrimalItem); }
    AShooterWeapon* GivePrimalItemWeaponForMission(UPrimalItem* aPrimalItem, AMissionType* AssociatedMission) { return NativeCall<AShooterWeapon*, UPrimalItem*, AMissionType*>(this, "AShooterCharacter.GivePrimalItemWeaponForMission", aPrimalItem, AssociatedMission); }
    void StartWeaponSwitch(UPrimalItem* aPrimalItem, bool bDontClearLastWeapon) { NativeCall<void, UPrimalItem*, bool>(this, "AShooterCharacter.StartWeaponSwitch", aPrimalItem, bDontClearLastWeapon); }
    void FinishWeaponSwitch() { NativeCall<void>(this, "AShooterCharacter.FinishWeaponSwitch"); }
    float GetMaxCursorHUDDistance(AShooterPlayerController* PC) { return NativeCall<float, AShooterPlayerController*>(this, "AShooterCharacter.GetMaxCursorHUDDistance", PC); }
    void DrawFloatingHUD(AShooterHUD* HUD) { NativeCall<void, AShooterHUD*>(this, "AShooterCharacter.DrawFloatingHUD", HUD); }
    void DestroyInventory() { NativeCall<void>(this, "AShooterCharacter.DestroyInventory"); }
    void OnRep_CurrentWeapon(AShooterWeapon* LastWeapon) { NativeCall<void, AShooterWeapon*>(this, "AShooterCharacter.OnRep_CurrentWeapon", LastWeapon); }
    void SetCurrentWeapon(AShooterWeapon* NewWeapon, AShooterWeapon* LastWeapon) { NativeCall<void, AShooterWeapon*, AShooterWeapon*>(this, "AShooterCharacter.SetCurrentWeapon", NewWeapon, LastWeapon); }
    void Serialize(FArchive* Ar) { NativeCall<void, FArchive*>(this, "AShooterCharacter.Serialize", 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", bNewTargeting); }
    void ServerSetTargeting_Implementation(bool bNewTargeting) { NativeCall<void, bool>(this, "AShooterCharacter.ServerSetTargeting_Implementation", bNewTargeting); }
    void ClientUpdateTranspondersInfo_Implementation(TArray<FTransponderInfo>* TranspondersInfo, bool bNewData) { NativeCall<void, TArray<FTransponderInfo>*, bool>(this, "AShooterCharacter.ClientUpdateTranspondersInfo_Implementation", TranspondersInfo, bNewData); }
    void ZoomIn() { NativeCall<void>(this, "AShooterCharacter.ZoomIn"); }
    void ZoomOut() { NativeCall<void>(this, "AShooterCharacter.ZoomOut"); }
    bool CanProne() { return NativeCall<bool>(this, "AShooterCharacter.CanProne"); }
    bool CanCrouch() { return NativeCall<bool>(this, "AShooterCharacter.CanCrouch"); }
    void OnPressCrouch() { NativeCall<void>(this, "AShooterCharacter.OnPressCrouch"); }
    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", HalfHeightAdjust, ScaledHalfHeightAdjust); }
    void OnStartCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust) { NativeCall<void, float, float>(this, "AShooterCharacter.OnStartCrouch", HalfHeightAdjust, ScaledHalfHeightAdjust); }
    void OnStartFire(bool bFromGamepadRight) { NativeCall<void, bool>(this, "AShooterCharacter.OnStartFire", bFromGamepadRight); }
    void OnStopFire(bool bFromGamepadRight) { NativeCall<void, bool>(this, "AShooterCharacter.OnStopFire", bFromGamepadRight); }
    void OnStartAltFire(bool bFromGamepad) { NativeCall<void, bool>(this, "AShooterCharacter.OnStartAltFire", bFromGamepad); }
    void OnStopAltFire(bool bFromGamepad) { NativeCall<void, bool>(this, "AShooterCharacter.OnStopAltFire", bFromGamepad); }
    void OnStartTargeting(bool bFromGamepadLeft) { NativeCall<void, bool>(this, "AShooterCharacter.OnStartTargeting", bFromGamepadLeft); }
    void OnStopTargeting(bool bFromGamepadLeft) { NativeCall<void, bool>(this, "AShooterCharacter.OnStopTargeting", bFromGamepadLeft); }
    void OnPressReload() { NativeCall<void>(this, "AShooterCharacter.OnPressReload"); }
    void OnReload() { NativeCall<void>(this, "AShooterCharacter.OnReload"); }
    void OnStartRunning() { NativeCall<void>(this, "AShooterCharacter.OnStartRunning"); }
    bool IsRunning() { return NativeCall<bool>(this, "AShooterCharacter.IsRunning"); }
    void SetSleeping(bool bSleeping, bool bUseRagdollLocationOffset) { NativeCall<void, bool, bool>(this, "AShooterCharacter.SetSleeping", bSleeping, bUseRagdollLocationOffset); }
    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", DeltaSeconds); }
    void UpdateCarriedLocationAndRotation(float DeltaSeconds) { NativeCall<void, float>(this, "AShooterCharacter.UpdateCarriedLocationAndRotation", DeltaSeconds); }
    float GetCarryingSocketYaw(bool RefreshBones) { return NativeCall<float, bool>(this, "AShooterCharacter.GetCarryingSocketYaw", RefreshBones); }
    bool CanBeCarried(APrimalCharacter* ByCarrier) { return NativeCall<bool, APrimalCharacter*>(this, "AShooterCharacter.CanBeCarried", ByCarrier); }
    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "AShooterCharacter.GetLifetimeReplicatedProps", OutLifetimeProps); }
    void OnRep_VivoxUsername() { NativeCall<void>(this, "AShooterCharacter.OnRep_VivoxUsername"); }
    void OnRep_CurrentVoiceModeAsUInt32() { NativeCall<void>(this, "AShooterCharacter.OnRep_CurrentVoiceModeAsUInt32"); }
    void ServerUpdateCurrentVoiceModeAsUInt32_Implementation(unsigned int NewValue) { NativeCall<void, unsigned int>(this, "AShooterCharacter.ServerUpdateCurrentVoiceModeAsUInt32_Implementation", NewValue); }
    void ServerSetIsVoiceActive_Implementation(bool IsActive) { NativeCall<void, bool>(this, "AShooterCharacter.ServerSetIsVoiceActive_Implementation", IsActive); }
    void ReplicateVoiceModeToClients() { NativeCall<void>(this, "AShooterCharacter.ReplicateVoiceModeToClients"); }
    AShooterWeapon* GetCurrentWeapon() { return NativeCall<AShooterWeapon*>(this, "AShooterCharacter.GetCurrentWeapon"); }
    FName* GetWeaponAttachPoint(FName* result) { return NativeCall<FName*, FName*>(this, "AShooterCharacter.GetWeaponAttachPoint", result); }
    float GetTargetingSpeedModifier() { return NativeCall<float>(this, "AShooterCharacter.GetTargetingSpeedModifier"); }
    float GetActualTargetingFOV(float DefaultTargetingFOV) { return NativeCall<float, float>(this, "AShooterCharacter.GetActualTargetingFOV", DefaultTargetingFOV); }
    bool IsTargeting() { return NativeCall<bool>(this, "AShooterCharacter.IsTargeting"); }
    bool IsFirstPerson() { return NativeCall<bool>(this, "AShooterCharacter.IsFirstPerson"); }
    bool IsCurrentPassengerLimitCameraYaw() { return NativeCall<bool>(this, "AShooterCharacter.IsCurrentPassengerLimitCameraYaw"); }
    void SetActorHiddenInGame(bool bNewHidden) { NativeCall<void, bool>(this, "AShooterCharacter.SetActorHiddenInGame", bNewHidden); }
    bool AllowFirstPerson() { return NativeCall<bool>(this, "AShooterCharacter.AllowFirstPerson"); }
    void SetCameraMode(bool bFirstperson, bool bIgnoreSettingFirstPersonRiding) { NativeCall<void, bool, bool>(this, "AShooterCharacter.SetCameraMode", bFirstperson, bIgnoreSettingFirstPersonRiding); }
    void StartCameraTransition(float Duration) { NativeCall<void, float>(this, "AShooterCharacter.StartCameraTransition", Duration); }
    void PlaySpawnIntro() { NativeCall<void>(this, "AShooterCharacter.PlaySpawnIntro"); }
    void FinishSpawnIntro() { NativeCall<void>(this, "AShooterCharacter.FinishSpawnIntro"); }
    bool ValidToRestoreForPC(AShooterPlayerController* aPC) { return NativeCall<bool, AShooterPlayerController*>(this, "AShooterCharacter.ValidToRestoreForPC", aPC); }
    static AShooterCharacter* FindForPlayerController(AShooterPlayerController* aPC) { return NativeCall<AShooterCharacter*, AShooterPlayerController*>(nullptr, "AShooterCharacter.FindForPlayerController", aPC); }
    FString* LinkedPlayerIDString(FString* result) { return NativeCall<FString*, FString*>(this, "AShooterCharacter.LinkedPlayerIDString", result); }
    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, FDamageEvent* DamageEvent, APawn* InstigatingPawn, AActor* DamageCauser) { NativeCall<void, float, FDamageEvent*, APawn*, AActor*>(this, "AShooterCharacter.PlayDying", KillingDamage, DamageEvent, InstigatingPawn, DamageCauser); }
    bool IsFiring() { return NativeCall<bool>(this, "AShooterCharacter.IsFiring"); }
    bool IsUsingShield() { return NativeCall<bool>(this, "AShooterCharacter.IsUsingShield"); }
    bool IsBlockingWithShield() { return NativeCall<bool>(this, "AShooterCharacter.IsBlockingWithShield"); }
    bool AllowBlockingWithShield() { return NativeCall<bool>(this, "AShooterCharacter.AllowBlockingWithShield"); }
    bool GetBlockingShieldOffsets(FVector* OutBlockingShieldFPVTranslation, FRotator* OutBlockingShieldFPVRotation) { return NativeCall<bool, FVector*, FRotator*>(this, "AShooterCharacter.GetBlockingShieldOffsets", OutBlockingShieldFPVTranslation, OutBlockingShieldFPVRotation); }
    void NetSimulatedForceUpdateAimedActors_Implementation(float OverrideMaxDistance) { NativeCall<void, float>(this, "AShooterCharacter.NetSimulatedForceUpdateAimedActors_Implementation", OverrideMaxDistance); }
    void ServerForceUpdatedAimedActors(float OverrideMaxDistance, bool bReplicateToSimulatedClients) { NativeCall<void, float, bool>(this, "AShooterCharacter.ServerForceUpdatedAimedActors", OverrideMaxDistance, bReplicateToSimulatedClients); }
    void ServerSetBallistaNewRotation_Implementation(float Pitch, float Yaw) { NativeCall<void, float, float>(this, "AShooterCharacter.ServerSetBallistaNewRotation_Implementation", Pitch, Yaw); }
    void ServerNotifyBallistaShot_Implementation(FHitResult Impact, FVector_NetQuantizeNormal ShootDir) { NativeCall<void, FHitResult, FVector_NetQuantizeNormal>(this, "AShooterCharacter.ServerNotifyBallistaShot_Implementation", Impact, ShootDir); }
    float GetMaxSpeedModifier() { return NativeCall<float>(this, "AShooterCharacter.GetMaxSpeedModifier"); }
    void SetRidingDino(APrimalDinoCharacter* aDino) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterCharacter.SetRidingDino", aDino); }
    void TryGiveGenesisSeasonPassItems(int AppID) { NativeCall<void, int>(this, "AShooterCharacter.TryGiveGenesisSeasonPassItems", AppID); }
    void ClearRidingDino(bool bFromDino, int OverrideUnboardDirection, bool bForceEvenIfBuffPreventsClear) { NativeCall<void, bool, int, bool>(this, "AShooterCharacter.ClearRidingDino", bFromDino, OverrideUnboardDirection, bForceEvenIfBuffPreventsClear); }
    void SetCarryingDino(APrimalDinoCharacter* aDino) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterCharacter.SetCarryingDino", aDino); }
    void ClearCarryingDino(bool bFromDino, bool bCancelAnyCarryBuffs) { NativeCall<void, bool, bool>(this, "AShooterCharacter.ClearCarryingDino", bFromDino, bCancelAnyCarryBuffs); }
    void SetRidingDinoAsPassenger(APrimalDinoCharacter* aDino, FSaddlePassengerSeatDefinition* SeatDefinition) { NativeCall<void, APrimalDinoCharacter*, FSaddlePassengerSeatDefinition*>(this, "AShooterCharacter.SetRidingDinoAsPassenger", aDino, SeatDefinition); }
    void ClearRidingDinoAsPassenger(bool bFromDino) { NativeCall<void, bool>(this, "AShooterCharacter.ClearRidingDinoAsPassenger", bFromDino); }
    void ServerLaunchMountedDino_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerLaunchMountedDino_Implementation"); }
    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, FDamageEvent* DamageEvent, AController* Killer, AActor* DamageCauser) { return NativeCall<bool, float, FDamageEvent*, AController*, AActor*>(this, "AShooterCharacter.Die", KillingDamage, DamageEvent, Killer, DamageCauser); }
    void ApplyDamageMomentum(float DamageTaken, FDamageEvent* DamageEvent, APawn* PawnInstigator, AActor* DamageCauser) { NativeCall<void, float, FDamageEvent*, APawn*, AActor*>(this, "AShooterCharacter.ApplyDamageMomentum", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }
    bool CanJumpInternal_Implementation() { return NativeCall<bool>(this, "AShooterCharacter.CanJumpInternal_Implementation"); }
    bool CanProneInternal() { return NativeCall<bool>(this, "AShooterCharacter.CanProneInternal"); }
    bool IsCrafting() { return NativeCall<bool>(this, "AShooterCharacter.IsCrafting"); }
    void RemoveAttachments(AActor* From, bool bIsSnapshot) { NativeCall<void, AActor*, bool>(this, "AShooterCharacter.RemoveAttachments", From, bIsSnapshot); }
    void NotifyEquippedItems() { NativeCall<void>(this, "AShooterCharacter.NotifyEquippedItems"); }
    UPrimalInventoryComponent* GetInventoryComponent(AActor* UseOtherActor) { return NativeCall<UPrimalInventoryComponent*, AActor*>(this, "AShooterCharacter.GetInventoryComponent", UseOtherActor); }
    void RefreshDefaultAttachments(AActor* UseOtherActor, bool bIsSnapshot) { NativeCall<void, AActor*, bool>(this, "AShooterCharacter.RefreshDefaultAttachments", UseOtherActor, bIsSnapshot); }
    void ClientMultiUse(APlayerController* ForPC, int UseIndex) { NativeCall<void, APlayerController*, int>(this, "AShooterCharacter.ClientMultiUse", ForPC, UseIndex); }
    bool TryMultiUse(APlayerController* ForPC, int UseIndex) { return NativeCall<bool, APlayerController*, int>(this, "AShooterCharacter.TryMultiUse", ForPC, UseIndex); }
    void RefreshTribeName() { NativeCall<void>(this, "AShooterCharacter.RefreshTribeName"); }
    void ChangeActorTeam(int NewTeam) { NativeCall<void, int>(this, "AShooterCharacter.ChangeActorTeam", NewTeam); }
    void ClientClearTribeRequest_Implementation() { NativeCall<void>(this, "AShooterCharacter.ClientClearTribeRequest_Implementation"); }
    void ClientNotifyTribeRequest_Implementation(FString* RequestTribeName, AShooterCharacter* PlayerCharacter) { NativeCall<void, FString*, AShooterCharacter*>(this, "AShooterCharacter.ClientNotifyTribeRequest_Implementation", RequestTribeName, PlayerCharacter); }
    void PlayDrinkingAnimation() { NativeCall<void>(this, "AShooterCharacter.PlayDrinkingAnimation"); }
    float GetCharacterAdditionalHypothermiaInsulationValue() { return NativeCall<float>(this, "AShooterCharacter.GetCharacterAdditionalHypothermiaInsulationValue"); }
    bool CalcIsIndoors() { return NativeCall<bool>(this, "AShooterCharacter.CalcIsIndoors"); }
    static bool IsIndoorsAtLoc(UWorld* theWorld, FVector* actorLoc) { return NativeCall<bool, UWorld*, FVector*>(nullptr, "AShooterCharacter.IsIndoorsAtLoc", theWorld, actorLoc); }
    float GetInsulationFromItem(FHitResult* HitOut, EPrimalItemStat::Type TypeInsulation) { return NativeCall<float, FHitResult*, EPrimalItemStat::Type>(this, "AShooterCharacter.GetInsulationFromItem", HitOut, TypeInsulation); }
    float GetCharacterAdditionalInsulationValueFromStructure(UWorld* theWorld, FVector* actorLoc, EPrimalItemStat::Type TypeInsulation) { return NativeCall<float, UWorld*, FVector*, EPrimalItemStat::Type>(this, "AShooterCharacter.GetCharacterAdditionalInsulationValueFromStructure", theWorld, actorLoc, TypeInsulation); }
    float GetCharacterAdditionalHyperthermiaInsulationValue() { return NativeCall<float>(this, "AShooterCharacter.GetCharacterAdditionalHyperthermiaInsulationValue"); }
    void PreInitializeComponents() { NativeCall<void>(this, "AShooterCharacter.PreInitializeComponents"); }
    void OnMovementModeChanged(EMovementMode PrevMovementMode, char PreviousCustomMode) { NativeCall<void, EMovementMode, char>(this, "AShooterCharacter.OnMovementModeChanged", PrevMovementMode, PreviousCustomMode); }
    void PreApplyAccumulatedForces(float DeltaSeconds, FVector* PendingImpulseToApply, FVector* PendingForceToApply) { NativeCall<void, float, FVector*, FVector*>(this, "AShooterCharacter.PreApplyAccumulatedForces", DeltaSeconds, PendingImpulseToApply, PendingForceToApply); }
    void OnBeginDrag_Implementation(APrimalCharacter* Dragged, int BoneIndex, bool bWithGrapHook) { NativeCall<void, APrimalCharacter*, int, bool>(this, "AShooterCharacter.OnBeginDrag_Implementation", 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", bDontCheckSwimming, bUseHalfThreshold, bForceCheck, bFromVolumeChange); }
    void UpdateSwimmingState() { NativeCall<void>(this, "AShooterCharacter.UpdateSwimmingState"); }
    void SetCharacterMeshesMaterialScalarParamValue(FName ParamName, float Value) { NativeCall<void, FName, float>(this, "AShooterCharacter.SetCharacterMeshesMaterialScalarParamValue", 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(ITargetableInterface* Attacker) { return NativeCall<float, ITargetableInterface*>(this, "AShooterCharacter.GetBaseTargetingDesire", Attacker); }
    void ApplyBodyColors() { NativeCall<void>(this, "AShooterCharacter.ApplyBodyColors"); }
    void ApplyBoneModifiers() { NativeCall<void>(this, "AShooterCharacter.ApplyBoneModifiers"); }
    void CaptureCharacterSnapshot(UPrimalItem* Item) { NativeCall<void, UPrimalItem*>(this, "AShooterCharacter.CaptureCharacterSnapshot", Item); }
    void ApplyCharacterSnapshot(UPrimalItem* Item, AActor* To, FVector Offset, float MaxExtent, int Pose) { NativeCall<void, UPrimalItem*, AActor*, FVector, float, int>(this, "AShooterCharacter.ApplyCharacterSnapshot", Item, To, Offset, MaxExtent, Pose); }
    void RemoveCharacterSnapshot(UPrimalItem* Item, AActor* From) { NativeCall<void, UPrimalItem*, AActor*>(this, "AShooterCharacter.RemoveCharacterSnapshot", Item, From); }
    float GetTargetingDesirability(ITargetableInterface* Attacker) { return NativeCall<float, ITargetableInterface*>(this, "AShooterCharacter.GetTargetingDesirability", Attacker); }
    UAnimMontage* GetOverridenMontage(UAnimMontage* AnimMontage) { return NativeCall<UAnimMontage*, UAnimMontage*>(this, "AShooterCharacter.GetOverridenMontage", AnimMontage); }
    UAnimSequence* GetOverridenAnimSequence(UAnimSequence* AnimSeq) { return NativeCall<UAnimSequence*, UAnimSequence*>(this, "AShooterCharacter.GetOverridenAnimSequence", AnimSeq); }
    bool IsWatered() { return NativeCall<bool>(this, "AShooterCharacter.IsWatered"); }
    bool CanDoUsableHarvesting() { return NativeCall<bool>(this, "AShooterCharacter.CanDoUsableHarvesting"); }
    void AdjustDamage(float* Damage, FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { NativeCall<void, float*, FDamageEvent*, AController*, AActor*>(this, "AShooterCharacter.AdjustDamage", Damage, DamageEvent, EventInstigator, DamageCauser); }
    bool IsBlockedByShield(FHitResult* HitInfo, FVector* ShotDirection, bool bBlockAllPointDamage) { return NativeCall<bool, FHitResult*, FVector*, bool>(this, "AShooterCharacter.IsBlockedByShield", HitInfo, ShotDirection, bBlockAllPointDamage); }
    void ClientNotifyLevelUp_Implementation() { NativeCall<void>(this, "AShooterCharacter.ClientNotifyLevelUp_Implementation"); }
    void StartedFiringWeapon(bool bPrimaryFire) { NativeCall<void, bool>(this, "AShooterCharacter.StartedFiringWeapon", bPrimaryFire); }
    void FiredWeapon() { NativeCall<void>(this, "AShooterCharacter.FiredWeapon"); }
    long double GetLastAttackTime() { return NativeCall<long double>(this, "AShooterCharacter.GetLastAttackTime"); }
    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", 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", ForDinoChar); }
    void ServerCallStay_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerCallStay_Implementation"); }
    void ServerCallStayOne_Implementation(APrimalDinoCharacter* ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterCharacter.ServerCallStayOne_Implementation", ForDinoChar); }
    void ServerCallFollowDistanceCycleOne_Implementation(APrimalDinoCharacter* ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterCharacter.ServerCallFollowDistanceCycleOne_Implementation", ForDinoChar); }
    void ServerCallAggressive_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerCallAggressive_Implementation"); }
    void ServerCallNeutral_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerCallNeutral_Implementation"); }
    void ServerCallPassive_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerCallPassive_Implementation"); }
    void ServerCallSetAggressive_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerCallSetAggressive_Implementation"); }
    void ServerCallAttackTarget_Implementation(AActor* TheTarget) { NativeCall<void, AActor*>(this, "AShooterCharacter.ServerCallAttackTarget_Implementation", TheTarget); }
    void ClientOrderedMoveTo_Implementation(FVector MoveToLoc) { NativeCall<void, FVector>(this, "AShooterCharacter.ClientOrderedMoveTo_Implementation", MoveToLoc); }
    void ClientOrderedAttackTarget_Implementation(AActor* attackTarget) { NativeCall<void, AActor*>(this, "AShooterCharacter.ClientOrderedAttackTarget_Implementation", attackTarget); }
    void ServerCallMoveTo_Implementation(FVector MoveToLoc) { NativeCall<void, FVector>(this, "AShooterCharacter.ServerCallMoveTo_Implementation", MoveToLoc); }
    void ServerCallLandFlyerOne_Implementation(APrimalDinoCharacter* ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterCharacter.ServerCallLandFlyerOne_Implementation", ForDinoChar); }
    bool TryAccessInventory() { return NativeCall<bool>(this, "AShooterCharacter.TryAccessInventory"); }
    void PlayEmoteAnimation_Implementation(char EmoteIndex) { NativeCall<void, char>(this, "AShooterCharacter.PlayEmoteAnimation_Implementation", EmoteIndex); }
    void PlayTalkingAnimation() { NativeCall<void>(this, "AShooterCharacter.PlayTalkingAnimation"); }
    void OnVoiceTalkingStateChanged(bool talking, bool IsUsingSuperRange) { NativeCall<void, bool, bool>(this, "AShooterCharacter.OnVoiceTalkingStateChanged", talking, IsUsingSuperRange); }
    ACharacter* GetTalkerCharacter() { return NativeCall<ACharacter*>(this, "AShooterCharacter.GetTalkerCharacter"); }
    FVector* GetTalkerLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AShooterCharacter.GetTalkerLocation", result); }
    void OnFailedJumped() { NativeCall<void>(this, "AShooterCharacter.OnFailedJumped"); }
    float GetRecoilMultiplier() { return NativeCall<float>(this, "AShooterCharacter.GetRecoilMultiplier"); }
    void StasisingCharacter() { NativeCall<void>(this, "AShooterCharacter.StasisingCharacter"); }
    bool UseAltAimOffsetAnim() { return NativeCall<bool>(this, "AShooterCharacter.UseAltAimOffsetAnim"); }
    bool UseAlternateStandingAnim() { return NativeCall<bool>(this, "AShooterCharacter.UseAlternateStandingAnim"); }
    UAnimSequence* GetAlternateStandingAnim(float* OutBlendInTime, float* OutBlendOutTime) { return NativeCall<UAnimSequence*, float*, float*>(this, "AShooterCharacter.GetAlternateStandingAnim", OutBlendInTime, OutBlendOutTime); }
    bool UseAdditiveStandingAnim() { return NativeCall<bool>(this, "AShooterCharacter.UseAdditiveStandingAnim"); }
    bool GetAdditiveStandingAnimNonAdditive() { return NativeCall<bool>(this, "AShooterCharacter.GetAdditiveStandingAnimNonAdditive"); }
    UAnimSequence* GetAdditiveStandingAnim(float* OutBlendInTime, float* OutBlendOutTime) { return NativeCall<UAnimSequence*, float*, float*>(this, "AShooterCharacter.GetAdditiveStandingAnim", OutBlendInTime, OutBlendOutTime); }
    void ClosedInventoryUI() { NativeCall<void>(this, "AShooterCharacter.ClosedInventoryUI"); }
    void ServerSetViewingInventory_Implementation(bool bIsViewing) { NativeCall<void, bool>(this, "AShooterCharacter.ServerSetViewingInventory_Implementation", bIsViewing); }
    bool AnimUseAimOffset() { return NativeCall<bool>(this, "AShooterCharacter.AnimUseAimOffset"); }
    void ServerCheckDrinkingWater_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerCheckDrinkingWater_Implementation"); }
    void GameStateHandleEvent_Implementation(FName NameParam, FVector VecParam) { NativeCall<void, FName, FVector>(this, "AShooterCharacter.GameStateHandleEvent_Implementation", NameParam, VecParam); }
    void CallGameStateHandleEvent(FName NameParam, FVector VecParam) { NativeCall<void, FName, FVector>(this, "AShooterCharacter.CallGameStateHandleEvent", NameParam, VecParam); }
    APrimalDinoCharacter* GetRidingDino() { return NativeCall<APrimalDinoCharacter*>(this, "AShooterCharacter.GetRidingDino"); }
    void AttachToLadder_Implementation(USceneComponent* Parent) { NativeCall<void, USceneComponent*>(this, "AShooterCharacter.AttachToLadder_Implementation", 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"); }
    void OnAttachedToSeatingStructure() { NativeCall<void>(this, "AShooterCharacter.OnAttachedToSeatingStructure"); }
    void OnDetachedFromSeatingStructure(APrimalStructureSeating* InSeatingStructure) { NativeCall<void, APrimalStructureSeating*>(this, "AShooterCharacter.OnDetachedFromSeatingStructure", InSeatingStructure); }
    void TakeSeatingStructure(APrimalStructureSeating* InSeatingStructure, int SeatNumber, bool bLockedToSeat) { NativeCall<void, APrimalStructureSeating*, int, bool>(this, "AShooterCharacter.TakeSeatingStructure", InSeatingStructure, SeatNumber, bLockedToSeat); }
    void ReleaseSeatingStructure(APrimalStructureSeating* InSeatingStructure) { NativeCall<void, APrimalStructureSeating*>(this, "AShooterCharacter.ReleaseSeatingStructure", InSeatingStructure); }
    bool ShouldReplicateRotPitch() { return NativeCall<bool>(this, "AShooterCharacter.ShouldReplicateRotPitch"); }
    bool IsUsingClimbingPick() { return NativeCall<bool>(this, "AShooterCharacter.IsUsingClimbingPick"); }
    void BreakGrapple() { NativeCall<void>(this, "AShooterCharacter.BreakGrapple"); }
    void ServerPlayFireBallistaAnimation_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerPlayFireBallistaAnimation_Implementation"); }
    void ServerStopFireBallista_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerStopFireBallista_Implementation"); }
    void ServerToClientsPlayFireBallistaAnimation_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerToClientsPlayFireBallistaAnimation_Implementation"); }
    void PlayeReloadBallistaAnimation() { NativeCall<void>(this, "AShooterCharacter.PlayeReloadBallistaAnimation"); }
    void ServerFireBallistaProjectile_Implementation(FVector Origin, FVector_NetQuantizeNormal ShootDir) { NativeCall<void, FVector, FVector_NetQuantizeNormal>(this, "AShooterCharacter.ServerFireBallistaProjectile_Implementation", Origin, ShootDir); }
    void ServerSeatingStructureAction_Implementation(char ActionNumber) { NativeCall<void, char>(this, "AShooterCharacter.ServerSeatingStructureAction_Implementation", ActionNumber); }
    void WasPushed(ACharacter* ByOtherCharacter) { NativeCall<void, ACharacter*>(this, "AShooterCharacter.WasPushed", ByOtherCharacter); }
    void NotifyBumpedPawn(APawn* BumpedPawn) { NativeCall<void, APawn*>(this, "AShooterCharacter.NotifyBumpedPawn", BumpedPawn); }
    void ClientNetEndClimbingLadder_Implementation() { NativeCall<void>(this, "AShooterCharacter.ClientNetEndClimbingLadder_Implementation"); }
    void ServerNetEndClimbingLadder_Implementation(bool bIsClimbOver, FVector ClimbOverLoc, float RightDir) { NativeCall<void, bool, FVector, float>(this, "AShooterCharacter.ServerNetEndClimbingLadder_Implementation", bIsClimbOver, ClimbOverLoc, RightDir); }
    void RenamePlayer_Implementation(FString* NewName) { NativeCall<void, FString*>(this, "AShooterCharacter.RenamePlayer_Implementation", NewName); }
    bool AllowDinoTargetingRange(FVector* AtLoc, float TargetingRange) { return NativeCall<bool, FVector*, float>(this, "AShooterCharacter.AllowDinoTargetingRange", AtLoc, TargetingRange); }
    FVector* GetPawnViewLocation(FVector* result, bool bAllTransforms) { return NativeCall<FVector*, FVector*, bool>(this, "AShooterCharacter.GetPawnViewLocation", result, bAllTransforms); }
    FRotator* GetPassengerAttachedRotation(FRotator* result) { return NativeCall<FRotator*, FRotator*>(this, "AShooterCharacter.GetPassengerAttachedRotation", result); }
    void ClientInviteToAlliance_Implementation(int RequestingTeam, unsigned int AllianceID, FString* AllianceName, FString* InviteeName) { NativeCall<void, int, unsigned int, FString*, FString*>(this, "AShooterCharacter.ClientInviteToAlliance_Implementation", 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", RequestingTeam, AllianceID, AllianceName, InviterName); }
    bool CanDragCharacter(APrimalCharacter* Character) { return NativeCall<bool, APrimalCharacter*>(this, "AShooterCharacter.CanDragCharacter", Character); }
    void GiveDefaultWeaponTimer() { NativeCall<void>(this, "AShooterCharacter.GiveDefaultWeaponTimer"); }
    bool IsCarryingSomething(bool bNotForRunning) { return NativeCall<bool, bool>(this, "AShooterCharacter.IsCarryingSomething", bNotForRunning); }
    void ForceGiveDefaultWeapon() { NativeCall<void>(this, "AShooterCharacter.ForceGiveDefaultWeapon"); }
    APrimalDinoCharacter* GetBasedOnDino() { return NativeCall<APrimalDinoCharacter*>(this, "AShooterCharacter.GetBasedOnDino"); }
    bool IsOutside() { return NativeCall<bool>(this, "AShooterCharacter.IsOutside"); }
    void HideWeapon() { NativeCall<void>(this, "AShooterCharacter.HideWeapon"); }
    void ShowWeapon() { NativeCall<void>(this, "AShooterCharacter.ShowWeapon"); }
    void ServerStartSurfaceCameraForPassenger_Implementation(float yaw, float roll, float pitch, bool bShouldInvertInput) { NativeCall<void, float, float, float, bool>(this, "AShooterCharacter.ServerStartSurfaceCameraForPassenger_Implementation", yaw, roll, pitch, bShouldInvertInput); }
    float ModifyAirControl(float AirControlIn) { return NativeCall<float, float>(this, "AShooterCharacter.ModifyAirControl", AirControlIn); }
    FVector* GetLastSweepLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AShooterCharacter.GetLastSweepLocation", result); }
    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", thePercent, newHeadHairIndex); }
    void NetSetFacialHairPercent_Implementation(float thePercent, int newFacialHairIndex) { NativeCall<void, float, int>(this, "AShooterCharacter.NetSetFacialHairPercent_Implementation", thePercent, newFacialHairIndex); }
    void UpdateHair() { NativeCall<void>(this, "AShooterCharacter.UpdateHair"); }
    int GetFacialHairIndex() { return NativeCall<int>(this, "AShooterCharacter.GetFacialHairIndex"); }
    int GetHeadHairIndex() { return NativeCall<int>(this, "AShooterCharacter.GetHeadHairIndex"); }
    FLinearColor* GetHeadHairColor(FLinearColor* result) { return NativeCall<FLinearColor*, FLinearColor*>(this, "AShooterCharacter.GetHeadHairColor", result); }
    FLinearColor* GetFacialHairColor(FLinearColor* result) { return NativeCall<FLinearColor*, FLinearColor*>(this, "AShooterCharacter.GetFacialHairColor", result); }
    void NetSetOverrideHeadHairColor_Implementation(FLinearColor HairColor) { NativeCall<void, FLinearColor>(this, "AShooterCharacter.NetSetOverrideHeadHairColor_Implementation", HairColor); }
    void NetSetOverrideFacialHairColor_Implementation(FLinearColor HairColor) { NativeCall<void, FLinearColor>(this, "AShooterCharacter.NetSetOverrideFacialHairColor_Implementation", HairColor); }
    void Unstasis() { NativeCall<void>(this, "AShooterCharacter.Unstasis"); }
    void RegisterActorTickFunctions(bool bRegister, bool bSaveAndRestoreTickState) { NativeCall<void, bool, bool>(this, "AShooterCharacter.RegisterActorTickFunctions", bRegister, bSaveAndRestoreTickState); }
    void OnRep_HatHidden() { NativeCall<void>(this, "AShooterCharacter.OnRep_HatHidden"); }
    float GetHeadHairMorphTargetValue() { return NativeCall<float>(this, "AShooterCharacter.GetHeadHairMorphTargetValue"); }
    static float ComputeHeadHairMorphTargetValue(bool bFemale, char HairIndex, float PercentOfGrowth) { return NativeCall<float, bool, char, float>(nullptr, "AShooterCharacter.ComputeHeadHairMorphTargetValue", bFemale, HairIndex, PercentOfGrowth); }
    float GetFacialHairMorphTargetValue() { return NativeCall<float>(this, "AShooterCharacter.GetFacialHairMorphTargetValue"); }
    static float ComputeFacialHairMorphTargetValue(bool bFemale, char HairIndex, float PercentOfGrowth) { return NativeCall<float, bool, char, float>(nullptr, "AShooterCharacter.ComputeFacialHairMorphTargetValue", bFemale, HairIndex, PercentOfGrowth); }
    void TempDampenInputAcceleration() { NativeCall<void>(this, "AShooterCharacter.TempDampenInputAcceleration"); }
    APrimalStructureExplosive* GetAttachedExplosive() { return NativeCall<APrimalStructureExplosive*>(this, "AShooterCharacter.GetAttachedExplosive"); }
    AShooterPlayerController* GetSpawnedForController() { return NativeCall<AShooterPlayerController*>(this, "AShooterCharacter.GetSpawnedForController"); }
    bool Poop(bool bForcePoop) { return NativeCall<bool, bool>(this, "AShooterCharacter.Poop", bForcePoop); }
    AActor* StructurePlacementUseAlternateOriginActor() { return NativeCall<AActor*>(this, "AShooterCharacter.StructurePlacementUseAlternateOriginActor"); }
    USceneComponent* GetActorSoundAttachmentComponentOverride(USceneComponent* ForComponent) { return NativeCall<USceneComponent*, USceneComponent*>(this, "AShooterCharacter.GetActorSoundAttachmentComponentOverride", ForComponent); }
    bool IsNearTopOfLadder() { return NativeCall<bool>(this, "AShooterCharacter.IsNearTopOfLadder"); }
    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(FRotator NewControlRotation, float DeltaTime, bool bFromController) { NativeCall<void, FRotator, float, bool>(this, "AShooterCharacter.FaceRotation", NewControlRotation, DeltaTime, bFromController); }
    bool IsGameInputAllowed() { return NativeCall<bool>(this, "AShooterCharacter.IsGameInputAllowed"); }
    bool IsReadyToUpload(UWorld* theWorld) { return NativeCall<bool, UWorld*>(this, "AShooterCharacter.IsReadyToUpload", theWorld); }
    void ServerClearSwitchingWeapon_Implementation(bool bOnlyIfDefaultWeapon, bool bClientRequestNextWeaponID) { NativeCall<void, bool, bool>(this, "AShooterCharacter.ServerClearSwitchingWeapon_Implementation", bOnlyIfDefaultWeapon, bClientRequestNextWeaponID); }
    void ClientReceiveNextWeaponID_Implementation(FItemNetID theItemID) { NativeCall<void, FItemNetID>(this, "AShooterCharacter.ClientReceiveNextWeaponID_Implementation", theItemID); }
    void DoCharacterDetachment(bool bIncludeRiding, bool bIncludeCarrying, APrimalBuff* BuffToIgnore) { NativeCall<void, bool, bool, APrimalBuff*>(this, "AShooterCharacter.DoCharacterDetachment", bIncludeRiding, bIncludeCarrying, BuffToIgnore); }
    bool IsCharacterHardAttached(bool bIgnoreRiding, bool bIgnoreCarried) { return NativeCall<bool, bool, bool>(this, "AShooterCharacter.IsCharacterHardAttached", bIgnoreRiding, bIgnoreCarried); }
    bool IsGrapplingHardAttached() { return NativeCall<bool>(this, "AShooterCharacter.IsGrapplingHardAttached"); }
    bool TeleportTo(FVector* DestLocation, FRotator* DestRotation, bool bIsATest, bool bNoCheck) { return NativeCall<bool, FVector*, FRotator*, bool, bool>(this, "AShooterCharacter.TeleportTo", DestLocation, DestRotation, bIsATest, bNoCheck); }
    FString* GetDebugInfoString(FString* result) { return NativeCall<FString*, FString*>(this, "AShooterCharacter.GetDebugInfoString", result); }
    FVector* GetTargetingLocation(FVector* result, AActor* Attacker) { return NativeCall<FVector*, FVector*, AActor*>(this, "AShooterCharacter.GetTargetingLocation", result, Attacker); }
    bool ForceCrosshair() { return NativeCall<bool>(this, "AShooterCharacter.ForceCrosshair"); }
    void WeaponUnequipped(AShooterWeapon* OldWeapon) { NativeCall<void, AShooterWeapon*>(this, "AShooterCharacter.WeaponUnequipped", OldWeapon); }
    void WeaponEquipped(AShooterWeapon* NewWeapon) { NativeCall<void, AShooterWeapon*>(this, "AShooterCharacter.WeaponEquipped", NewWeapon); }
    void SetAutoPlayer(bool bEnable) { NativeCall<void, bool>(this, "AShooterCharacter.SetAutoPlayer", bEnable); }
    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", AnimMontage, InPlayRate, StartSectionName, bForceTickPoseAndServerUpdateMesh, bForceTickPoseOnServer, BlendInTime, BlendOutTime); }
    bool GetAllAttachedCharsInternal(TSet<APrimalCharacter*, DefaultKeyFuncs<APrimalCharacter*, 0>, FDefaultSetAllocator>* AttachedChars, APrimalCharacter* OriginalChar, const bool bIncludeBased, const bool bIncludePassengers, const bool bIncludeCarried) { return NativeCall<bool, TSet<APrimalCharacter*, DefaultKeyFuncs<APrimalCharacter*, 0>, FDefaultSetAllocator>*, APrimalCharacter*, const bool, const bool, const bool>(this, "AShooterCharacter.GetAllAttachedCharsInternal", AttachedChars, OriginalChar, bIncludeBased, bIncludePassengers, bIncludeCarried); }
    bool IsWatchingExplorerNote() { return NativeCall<bool>(this, "AShooterCharacter.IsWatchingExplorerNote"); }
    int GiveHexagons(int NumHexagons, int TriggerIndex, float OverrideHexGainFalloffRate, int OverrideHexGainFalloffMin, float OverrideCollectSFXVolume, FVector OverrideVfxSpawnLoc, int OverrideHexagonVFXActorCount, bool VFXImmediatelyAttracts) { return NativeCall<int, int, int, float, int, float, FVector, int, bool>(this, "AShooterCharacter.GiveHexagons", NumHexagons, TriggerIndex, OverrideHexGainFalloffRate, OverrideHexGainFalloffMin, OverrideCollectSFXVolume, OverrideVfxSpawnLoc, OverrideHexagonVFXActorCount, VFXImmediatelyAttracts); }
    int GiveHexagonsOnMissionReward(FName MissionTag, int BonusEarnedHexagons, int HexagonAmountOverride) { return NativeCall<int, FName, int, int>(this, "AShooterCharacter.GiveHexagonsOnMissionReward", MissionTag, BonusEarnedHexagons, HexagonAmountOverride); }
    void ClientsSpawnHexagonVFX_Implementation(int NumHexagons, float OverrideCollectSFXVolume, FVector OverrideVfxSpawnLoc, int OverrideHexagonVFXActorCount, bool VFXImmediatelyAttracts) { NativeCall<void, int, float, FVector, int, bool>(this, "AShooterCharacter.ClientsSpawnHexagonVFX_Implementation", NumHexagons, OverrideCollectSFXVolume, OverrideVfxSpawnLoc, OverrideHexagonVFXActorCount, VFXImmediatelyAttracts); }
    bool SetPlayerHexagonCount(int NewHexagonCount) { return NativeCall<bool, int>(this, "AShooterCharacter.SetPlayerHexagonCount", NewHexagonCount); }
    int GetPlayerHexagonCount() { return NativeCall<int>(this, "AShooterCharacter.GetPlayerHexagonCount"); }
    void ServerRequestHexagonTrade_Implementation(int RequestedTradableItemIndex, int Quantity) { NativeCall<void, int, int>(this, "AShooterCharacter.ServerRequestHexagonTrade_Implementation", RequestedTradableItemIndex, Quantity); }
    bool IsPlayingInitialSpawnAnim() { return NativeCall<bool>(this, "AShooterCharacter.IsPlayingInitialSpawnAnim"); }
    bool IsPlayingRepawnAnim() { return NativeCall<bool>(this, "AShooterCharacter.IsPlayingRepawnAnim"); }
    bool BPSetPlayerHexagonCount_Implementation(int NewHexagonCount) { return NativeCall<bool, int>(this, "AShooterCharacter.BPSetPlayerHexagonCount_Implementation", NewHexagonCount); }
    int BPGetPlayerHexagonCount_Implementation() { return NativeCall<int>(this, "AShooterCharacter.BPGetPlayerHexagonCount_Implementation"); }
    bool CanEquipWeapons() { return NativeCall<bool>(this, "AShooterCharacter.CanEquipWeapons"); }
    void SetPreventEquipAllWeapons(const bool bPrevent) { NativeCall<void, const bool>(this, "AShooterCharacter.SetPreventEquipAllWeapons", bPrevent); }
    bool IsRider() { return NativeCall<bool>(this, "AShooterCharacter.IsRider"); }
    unsigned __int64 GetLinkedPlayerDataID() { return NativeCall<unsigned __int64>(this, "AShooterCharacter.GetLinkedPlayerDataID"); }
    bool IsVoiceWhispering() { return NativeCall<bool>(this, "AShooterCharacter.IsVoiceWhispering"); }
    bool IsVoiceTalking() { return NativeCall<bool>(this, "AShooterCharacter.IsVoiceTalking"); }
    unsigned int GetUniqueNetIdTypeHash() { return NativeCall<unsigned int>(this, "AShooterCharacter.GetUniqueNetIdTypeHash"); }
    bool IsSitting(bool bIgnoreLockedToSeat) { return NativeCall<bool, bool>(this, "AShooterCharacter.IsSitting", bIgnoreLockedToSeat); }
    bool IsProneOrSitting(bool bIgnoreLockedToSeat) { return NativeCall<bool, bool>(this, "AShooterCharacter.IsProneOrSitting", bIgnoreLockedToSeat); }
    bool IsVoiceSilent() { return NativeCall<bool>(this, "AShooterCharacter.IsVoiceSilent"); }
    UPrimalItem* GetShieldItem() { return NativeCall<UPrimalItem*>(this, "AShooterCharacter.GetShieldItem"); }
    bool IsVoiceYelling() { return NativeCall<bool>(this, "AShooterCharacter.IsVoiceYelling"); }
    void SetVivoxUsername(FString* Value) { NativeCall<void, FString*>(this, "AShooterCharacter.SetVivoxUsername", Value); }
    static void StaticRegisterNativesAShooterCharacter() { NativeCall<void>(nullptr, "AShooterCharacter.StaticRegisterNativesAShooterCharacter"); }
    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "AShooterCharacter.GetPrivateStaticClass", Package); }
    void AttachToLadder(USceneComponent* Parent) { NativeCall<void, USceneComponent*>(this, "AShooterCharacter.AttachToLadder", Parent); }
    int BPGetPlayerHexagonCount() { return NativeCall<int>(this, "AShooterCharacter.BPGetPlayerHexagonCount"); }
    bool BPSetPlayerHexagonCount(int NewHexagonCount) { return NativeCall<bool, int>(this, "AShooterCharacter.BPSetPlayerHexagonCount", NewHexagonCount); }
    void ClientClearTribeRequest() { NativeCall<void>(this, "AShooterCharacter.ClientClearTribeRequest"); }
    void ClientInviteToAlliance(int RequestingTeam, unsigned int AllianceID, FString* AllianceName, FString* InviteeName) { NativeCall<void, int, unsigned int, FString*, FString*>(this, "AShooterCharacter.ClientInviteToAlliance", RequestingTeam, AllianceID, AllianceName, InviteeName); }
    void ClientNetEndClimbingLadder() { NativeCall<void>(this, "AShooterCharacter.ClientNetEndClimbingLadder"); }
    void ClientNotifyTribeRequest(FString* RequestTribeName, AShooterCharacter* PlayerCharacter) { NativeCall<void, FString*, AShooterCharacter*>(this, "AShooterCharacter.ClientNotifyTribeRequest", RequestTribeName, PlayerCharacter); }
    void ClientOrderedAttackTarget(AActor* attackTarget) { NativeCall<void, AActor*>(this, "AShooterCharacter.ClientOrderedAttackTarget", attackTarget); }
    void ClientOrderedMoveTo(FVector MoveToLoc) { NativeCall<void, FVector>(this, "AShooterCharacter.ClientOrderedMoveTo", MoveToLoc); }
    void ClientPlayHarvestAnim() { NativeCall<void>(this, "AShooterCharacter.ClientPlayHarvestAnim"); }
    void ClientReceiveNextWeaponID(FItemNetID theItemID) { NativeCall<void, FItemNetID>(this, "AShooterCharacter.ClientReceiveNextWeaponID", theItemID); }
    void ClientsSpawnHexagonVFX(int NumHexagons, float OverrideCollectSFXVolume, FVector OverrideVfxSpawnLoc, int OverrideHexagonVFXActorCount, bool VFXImmediatelyAttracts) { NativeCall<void, int, float, FVector, int, bool>(this, "AShooterCharacter.ClientsSpawnHexagonVFX", NumHexagons, OverrideCollectSFXVolume, OverrideVfxSpawnLoc, OverrideHexagonVFXActorCount, VFXImmediatelyAttracts); }
    void ClientUpdateTranspondersInfo(TArray<FTransponderInfo>* TranspondersInfo, bool bNewData) { NativeCall<void, TArray<FTransponderInfo>*, bool>(this, "AShooterCharacter.ClientUpdateTranspondersInfo", TranspondersInfo, bNewData); }
    void DetachFromLadder() { NativeCall<void>(this, "AShooterCharacter.DetachFromLadder"); }
    void DetachGrapHookCable() { NativeCall<void>(this, "AShooterCharacter.DetachGrapHookCable"); }
    void GameStateHandleEvent(FName NameParam, FVector VecParam) { NativeCall<void, FName, FVector>(this, "AShooterCharacter.GameStateHandleEvent", NameParam, VecParam); }
    bool IsPlayingUpperBodyCallAnimation() { return NativeCall<bool>(this, "AShooterCharacter.IsPlayingUpperBodyCallAnimation"); }
    void NetSetFacialHairPercent(float thePercent, int newFacialHairIndex) { NativeCall<void, float, int>(this, "AShooterCharacter.NetSetFacialHairPercent", thePercent, newFacialHairIndex); }
    void NetSetHeadHairPercent(float thePercent, int newHeadHairIndex) { NativeCall<void, float, int>(this, "AShooterCharacter.NetSetHeadHairPercent", thePercent, newHeadHairIndex); }
    void NetSimulatedForceUpdateAimedActors(float OverrideMaxDistance) { NativeCall<void, float>(this, "AShooterCharacter.NetSimulatedForceUpdateAimedActors", OverrideMaxDistance); }
    void OnWeaponEquipped(AShooterWeapon* NewWeapon) { NativeCall<void, AShooterWeapon*>(this, "AShooterCharacter.OnWeaponEquipped", NewWeapon); }
    void OnWeaponUnequipped(AShooterWeapon* OldWeapon) { NativeCall<void, AShooterWeapon*>(this, "AShooterCharacter.OnWeaponUnequipped", OldWeapon); }
    void PlayEmoteAnimation(char EmoteIndex) { NativeCall<void, char>(this, "AShooterCharacter.PlayEmoteAnimation", EmoteIndex); }
    void RenamePlayer(FString* NewName) { NativeCall<void, FString*>(this, "AShooterCharacter.RenamePlayer", NewName); }
    void ServerCheckDrinkingWater() { NativeCall<void>(this, "AShooterCharacter.ServerCheckDrinkingWater"); }
    void ServerDetachGrapHookCable(bool bDoUpwardsJump, float UpwardsJumpYaw) { NativeCall<void, bool, float>(this, "AShooterCharacter.ServerDetachGrapHookCable", bDoUpwardsJump, UpwardsJumpYaw); }
    void ServerFireBallistaProjectile(FVector Origin, FVector_NetQuantizeNormal ShootDir) { NativeCall<void, FVector, FVector_NetQuantizeNormal>(this, "AShooterCharacter.ServerFireBallistaProjectile", Origin, ShootDir); }
    void ServerLaunchMountedDino() { NativeCall<void>(this, "AShooterCharacter.ServerLaunchMountedDino"); }
    void ServerNetEndClimbingLadder(bool bIsClimbOver, FVector ClimbOverLoc, float RightDir) { NativeCall<void, bool, FVector, float>(this, "AShooterCharacter.ServerNetEndClimbingLadder", bIsClimbOver, ClimbOverLoc, RightDir); }
    void ServerNotifyBallistaShot(FHitResult Impact, FVector_NetQuantizeNormal ShootDir) { NativeCall<void, FHitResult, FVector_NetQuantizeNormal>(this, "AShooterCharacter.ServerNotifyBallistaShot", Impact, ShootDir); }
    void ServerPlayFireBallistaAnimation() { NativeCall<void>(this, "AShooterCharacter.ServerPlayFireBallistaAnimation"); }
    void ServerReleaseGrapHookCable(bool bReleasing) { NativeCall<void, bool>(this, "AShooterCharacter.ServerReleaseGrapHookCable", bReleasing); }
    void ServerRequestHexagonTrade(int RequestedTradableItemIndex, int Quantity) { NativeCall<void, int, int>(this, "AShooterCharacter.ServerRequestHexagonTrade", RequestedTradableItemIndex, Quantity); }
    void ServerSeatingStructureAction(char ActionNumber) { NativeCall<void, char>(this, "AShooterCharacter.ServerSeatingStructureAction", ActionNumber); }
    void ServerSetBallistaNewRotation(float Pitch, float Yaw) { NativeCall<void, float, float>(this, "AShooterCharacter.ServerSetBallistaNewRotation", Pitch, Yaw); }
    void ServerSetIsVoiceActive(bool IsActive) { NativeCall<void, bool>(this, "AShooterCharacter.ServerSetIsVoiceActive", IsActive); }
    void ServerSetTargeting(bool bNewTargeting) { NativeCall<void, bool>(this, "AShooterCharacter.ServerSetTargeting", bNewTargeting); }
    void ServerSetViewingInventory(bool bIsViewing) { NativeCall<void, bool>(this, "AShooterCharacter.ServerSetViewingInventory", bIsViewing); }
    void ServerStartSurfaceCameraForPassenger(float yaw, float pitch, float roll, bool bShouldInvertInput) { NativeCall<void, float, float, float, bool>(this, "AShooterCharacter.ServerStartSurfaceCameraForPassenger", yaw, pitch, roll, bShouldInvertInput); }
    void ServerStopFireBallista() { NativeCall<void>(this, "AShooterCharacter.ServerStopFireBallista"); }
    void ServerSwitchMap() { NativeCall<void>(this, "AShooterCharacter.ServerSwitchMap"); }
    void ServerToClientsPlayFireBallistaAnimation() { NativeCall<void>(this, "AShooterCharacter.ServerToClientsPlayFireBallistaAnimation"); }
    void ServerUpdateCurrentVoiceModeAsUInt32(unsigned int NewValue) { NativeCall<void, unsigned int>(this, "AShooterCharacter.ServerUpdateCurrentVoiceModeAsUInt32", NewValue); }
    void SetCarriedPitchYaw(float NewCarriedPitch, float NewCarriedYaw) { NativeCall<void, float, float>(this, "AShooterCharacter.SetCarriedPitchYaw", NewCarriedPitch, NewCarriedYaw); }
    void SyncGrapHookDistance(float Distance) { NativeCall<void, float>(this, "AShooterCharacter.SyncGrapHookDistance", Distance); }
    void BPUnlockedAllExplorerNotes() { NativeCall<void>(this, "AShooterCharacter.BPUnlockedAllExplorerNotes"); }
};
 
struct FPrimalPersistentCharacterStatsStruct
{
    unsigned __int16& CharacterStatusComponent_ExtraCharacterLevelField() { return *GetNativePointerField<unsigned __int16*>(this, "FPrimalPersistentCharacterStatsStruct.CharacterStatusComponent_ExtraCharacterLevel"); }
    float& CharacterStatusComponent_ExperiencePointsField() { return *GetNativePointerField<float*>(this, "FPrimalPersistentCharacterStatsStruct.CharacterStatusComponent_ExperiencePoints"); }
    int& PlayerState_TotalEngramPointsField() { return *GetNativePointerField<int*>(this, "FPrimalPersistentCharacterStatsStruct.PlayerState_TotalEngramPoints"); }
    int& CharacterStatusComponent_HighestExtraCharacterLevelField() { return *GetNativePointerField<int*>(this, "FPrimalPersistentCharacterStatsStruct.CharacterStatusComponent_HighestExtraCharacterLevel"); }
    int& CharacterStatusComponent_LastRespecAtExtraCharacterLevelField() { return *GetNativePointerField<int*>(this, "FPrimalPersistentCharacterStatsStruct.CharacterStatusComponent_LastRespecAtExtraCharacterLevel"); }
    long double& CharacterStatusComponent_LastRespecUtcTimeSecondsField() { return *GetNativePointerField<long double*>(this, "FPrimalPersistentCharacterStatsStruct.CharacterStatusComponent_LastRespecUtcTimeSeconds"); }
    TArray<unsigned int>& PerMapExplorerNoteUnlocksField() { return *GetNativePointerField<TArray<unsigned int>*>(this, "FPrimalPersistentCharacterStatsStruct.PerMapExplorerNoteUnlocks"); }
    TArray<FName>& EmoteUnlocksField() { return *GetNativePointerField<TArray<FName>*>(this, "FPrimalPersistentCharacterStatsStruct.EmoteUnlocks"); }
    TArray<TSubclassOf<UPrimalItem>>& PlayerState_EngramBlueprintsField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalItem>>*>(this, "FPrimalPersistentCharacterStatsStruct.PlayerState_EngramBlueprints"); }
    FieldArray<char, 12> CharacterStatusComponent_NumberOfLevelUpPointsAppliedField() { return { this, "FPrimalPersistentCharacterStatsStruct.CharacterStatusComponent_NumberOfLevelUpPointsApplied" }; }
    FieldArray<TSubclassOf<UPrimalItem>, 10> PlayerState_DefaultItemSlotClassesField() { return { this, "FPrimalPersistentCharacterStatsStruct.PlayerState_DefaultItemSlotClasses" }; }
    FieldArray<char, 10> PlayerState_DefaultItemSlotEngramsField() { return { this, "FPrimalPersistentCharacterStatsStruct.PlayerState_DefaultItemSlotEngrams" }; }
    FieldArray<FDinoOrderGroup, 10> DinoOrderGroupsField() { return { this, "FPrimalPersistentCharacterStatsStruct.DinoOrderGroups" }; }
    int& CurrentlySelectedDinoOrderGroupField() { return *GetNativePointerField<int*>(this, "FPrimalPersistentCharacterStatsStruct.CurrentlySelectedDinoOrderGroup"); }
    float& PercentageOfHeadHairGrowthField() { return *GetNativePointerField<float*>(this, "FPrimalPersistentCharacterStatsStruct.PercentageOfHeadHairGrowth"); }
    bool& bHasUnlockedAllExplorerNotes() { return *GetNativePointerField<bool*>(this, "FPrimalPersistentCharacterStatsStruct.bHasUnlockedAllExplorerNotes"); }
    float& PercentageOfFacialHairGrowthField() { return *GetNativePointerField<float*>(this, "FPrimalPersistentCharacterStatsStruct.PercentageOfFacialHairGrowth"); }
    char& FacialHairIndexField() { return *GetNativePointerField<char*>(this, "FPrimalPersistentCharacterStatsStruct.FacialHairIndex"); }
    char& HeadHairIndexField() { return *GetNativePointerField<char*>(this, "FPrimalPersistentCharacterStatsStruct.HeadHairIndex"); }
 
    // Functions
 
    FPrimalPersistentCharacterStatsStruct* operator=(FPrimalPersistentCharacterStatsStruct* __that) { return NativeCall<FPrimalPersistentCharacterStatsStruct*, FPrimalPersistentCharacterStatsStruct*>(this, "FPrimalPersistentCharacterStatsStruct.operator=", __that); }
    bool IsPerMapExplorerNoteUnlocked(int ExplorerNoteIndex) { return NativeCall<bool, int>(this, "FPrimalPersistentCharacterStatsStruct.IsPerMapExplorerNoteUnlocked", ExplorerNoteIndex); }
    void ApplyToPrimalCharacter(APrimalCharacter* aChar, AShooterPlayerController* forPC, bool bIgnoreStats) { NativeCall<void, APrimalCharacter*, AShooterPlayerController*, bool>(this, "FPrimalPersistentCharacterStatsStruct.ApplyToPrimalCharacter", aChar, forPC, bIgnoreStats); }
    void GiveEngramsToPlayerState(APrimalCharacter* aChar, AShooterPlayerController* forPC) { NativeCall<void, APrimalCharacter*, AShooterPlayerController*>(this, "FPrimalPersistentCharacterStatsStruct.GiveEngramsToPlayerState", aChar, forPC); }
    void UnlockEmote(FName EmoteName) { NativeCall<void, FName>(this, "FPrimalPersistentCharacterStatsStruct.UnlockEmote", EmoteName); }
    bool IsEmoteUnlocked(FName EmoteName) { return NativeCall<bool, FName>(this, "FPrimalPersistentCharacterStatsStruct.IsEmoteUnlocked", EmoteName); }
    void UnlockPerMapExplorerNote(int ExplorerNoteIndex) { NativeCall<void, int>(this, "FPrimalPersistentCharacterStatsStruct.UnlockPerMapExplorerNote", ExplorerNoteIndex); }
    static UScriptStruct* StaticStruct() { return NativeCall<UScriptStruct*>(nullptr, "FPrimalPersistentCharacterStatsStruct.StaticStruct"); }
};
 
struct FPrimalPlayerDataStruct
{
    unsigned __int64& PlayerDataIDField() { return *GetNativePointerField<unsigned __int64*>(this, "FPrimalPlayerDataStruct.PlayerDataID"); }
    FUniqueNetIdRepl& UniqueIDField() { return *GetNativePointerField<FUniqueNetIdRepl*>(this, "FPrimalPlayerDataStruct.UniqueID"); }
    FString& SavedNetworkAddressField() { return *GetNativePointerField<FString*>(this, "FPrimalPlayerDataStruct.SavedNetworkAddress"); }
    FString& PlayerNameField() { return *GetNativePointerField<FString*>(this, "FPrimalPlayerDataStruct.PlayerName"); }
    unsigned int& LocalPlayerIndexField() { return *GetNativePointerField<unsigned int*>(this, "FPrimalPlayerDataStruct.LocalPlayerIndex"); }
    FPrimalPlayerCharacterConfigStruct& MyPlayerCharacterConfigField() { return *GetNativePointerField<FPrimalPlayerCharacterConfigStruct*>(this, "FPrimalPlayerDataStruct.MyPlayerCharacterConfig"); }
    int& LastPinCodeUsedField() { return *GetNativePointerField<int*>(this, "FPrimalPlayerDataStruct.LastPinCodeUsed"); }
    FPrimalPersistentCharacterStatsStruct* MyPersistentCharacterStatsField() { return GetNativePointerField<FPrimalPersistentCharacterStatsStruct*>(this, "FPrimalPlayerDataStruct.MyPersistentCharacterStats"); }
    int& NumPersonalDinosField() { return *GetNativePointerField<int*>(this, "FPrimalPlayerDataStruct.NumPersonalDinos"); }
    int& TribeIDField() { return *GetNativePointerField<int*>(this, "FPrimalPlayerDataStruct.TribeID"); }
    TArray<int>& AppIDSetField() { return *GetNativePointerField<TArray<int>*>(this, "FPrimalPlayerDataStruct.AppIDSet"); }
    int& PlayerDataVersionField() { return *GetNativePointerField<int*>(this, "FPrimalPlayerDataStruct.PlayerDataVersion"); }
    long double& NextAllowedRespawnTimeField() { return *GetNativePointerField<long double*>(this, "FPrimalPlayerDataStruct.NextAllowedRespawnTime"); }
    long double& LastTimeDiedToEnemyTeamField() { return *GetNativePointerField<long double*>(this, "FPrimalPlayerDataStruct.LastTimeDiedToEnemyTeam"); }
    long double& LoginTimeField() { return *GetNativePointerField<long double*>(this, "FPrimalPlayerDataStruct.LoginTime"); }
    long double& LastLoginTimeField() { return *GetNativePointerField<long double*>(this, "FPrimalPlayerDataStruct.LastLoginTime"); }
    float& AllowedRespawnIntervalField() { return *GetNativePointerField<float*>(this, "FPrimalPlayerDataStruct.AllowedRespawnInterval"); }
    float& NumOfDeathsField() { return *GetNativePointerField<float*>(this, "FPrimalPlayerDataStruct.NumOfDeaths"); }
    int& SpawnDayNumberField() { return *GetNativePointerField<int*>(this, "FPrimalPlayerDataStruct.SpawnDayNumber"); }
    float& SpawnDayTimeField() { return *GetNativePointerField<float*>(this, "FPrimalPlayerDataStruct.SpawnDayTime"); }
    TArray<FLatestMissionScore>& LatestMissionScoresField() { return *GetNativePointerField<TArray<FLatestMissionScore>*>(this, "FPrimalPlayerDataStruct.LatestMissionScores"); }
 
    // Bit fields
 
    BitFieldValue<bool, unsigned __int32> bFirstSpawned() { return { this, "FPrimalPlayerDataStruct.bFirstSpawned" }; }
    BitFieldValue<bool, unsigned __int32> bUseSpectator() { return { this, "FPrimalPlayerDataStruct.bUseSpectator" }; }
 
    // Functions
 
    FPrimalPlayerDataStruct* operator=(FPrimalPlayerDataStruct* __that) { return NativeCall<FPrimalPlayerDataStruct*, FPrimalPlayerDataStruct*>(this, "FPrimalPlayerDataStruct.operator=", __that); }
    static UScriptStruct* StaticStruct() { return NativeCall<UScriptStruct*>(nullptr, "FPrimalPlayerDataStruct.StaticStruct"); }
};
 
struct UPrimalPlayerData : UObject
{
    FPrimalPlayerDataStruct* MyDataField() { return GetNativePointerField<FPrimalPlayerDataStruct*>(this, "UPrimalPlayerData.MyData"); }
    TArray<UPrimalBuffPersistentData*> MyPersistentBuffDatasField() { return *GetNativePointerField<TArray<UPrimalBuffPersistentData*>*>(this, "UPrimalPlayerData.MyPersistentBuffDatas"); }
    bool& bIsLocalPlayerField() { return *GetNativePointerField<bool*>(this, "UPrimalPlayerData.bIsLocalPlayer"); }
    float& LastXPWritePercentField() { return *GetNativePointerField<float*>(this, "UPrimalPlayerData.LastXPWritePercent"); }
    TMap<FName, int, FDefaultSetAllocator, TDefaultMapKeyFuncs<FName, int, 0> >& MissionTagToLatestMissionScoreField() { return *GetNativePointerField<TMap<FName, int, FDefaultSetAllocator, TDefaultMapKeyFuncs<FName, int, 0> >*>(this, "UPrimalPlayerData.MissionTagToLatestMissionScore"); }
 
    // Functions
 
    bool LoadFromFile(FObjectReader* Reader) { return NativeCall<bool, FObjectReader*>(this, "UPrimalPlayerData.LoadFromFile", Reader); }
    FLatestMissionScore* GetOrCreateLatestMissionScore(FName MissionTag, bool bCreate) { return NativeCall<FLatestMissionScore*, FName, bool>(this, "UPrimalPlayerData.GetOrCreateLatestMissionScore", MissionTag, bCreate); }
    void SaveToFile(FObjectWriter* Writer) { NativeCall<void, FObjectWriter*>(this, "UPrimalPlayerData.SaveToFile", Writer); }
    bool MatchesPlayer(AShooterPlayerState* aPlayerState, bool bCheckForExistingPlayer) { return NativeCall<bool, AShooterPlayerState*, bool>(this, "UPrimalPlayerData.MatchesPlayer", aPlayerState, bCheckForExistingPlayer); }
    void InitForPlayer(AShooterPlayerState* aPlayerState, bool bDontSaveData) { NativeCall<void, AShooterPlayerState*, bool>(this, "UPrimalPlayerData.InitForPlayer", aPlayerState, bDontSaveData); }
    AShooterPlayerState* GetPlayerState(AShooterPlayerState* ignorePlayerState, bool bOnlyCheckExistingPlayers) { return NativeCall<AShooterPlayerState*, AShooterPlayerState*, bool>(this, "UPrimalPlayerData.GetPlayerState", ignorePlayerState, bOnlyCheckExistingPlayers); }
    static UPrimalPlayerData* GetDataForID(unsigned __int64 PlayerDataID) { return NativeCall<UPrimalPlayerData*, unsigned __int64>(nullptr, "UPrimalPlayerData.GetDataForID", PlayerDataID); }
    int GetTribeTeamID() { return NativeCall<int>(this, "UPrimalPlayerData.GetTribeTeamID"); }
    FString* LinkedPlayerIDString(FString* result) { return NativeCall<FString*, FString*>(this, "UPrimalPlayerData.LinkedPlayerIDString", result); }
    void ApplyToPlayerState(AShooterPlayerState* aPlayerState) { NativeCall<void, AShooterPlayerState*>(this, "UPrimalPlayerData.ApplyToPlayerState", aPlayerState); }
    void GiveInitialItems(int AppID, AShooterPlayerController* ForPC) { NativeCall<void, int, AShooterPlayerController*>(this, "UPrimalPlayerData.GiveInitialItems", AppID, ForPC); }
    void SetSubscribedApp(int AppID, AShooterPlayerController* ForPC) { NativeCall<void, int, AShooterPlayerController*>(this, "UPrimalPlayerData.SetSubscribedApp", AppID, ForPC); }
    FString* GetUniqueIdString(FString* result) { return NativeCall<FString*, FString*>(this, "UPrimalPlayerData.GetUniqueIdString", result); }
    void SavePlayerData(UWorld* ForWorld) { NativeCall<void, UWorld*>(this, "UPrimalPlayerData.SavePlayerData", ForWorld); }
    AShooterCharacter* FindCharacterForPlayer(UWorld* inWorld) { return NativeCall<AShooterCharacter*, UWorld*>(this, "UPrimalPlayerData.FindCharacterForPlayer", inWorld); }
    void ApplyToPlayerCharacter(AShooterPlayerState* ForPlayerState, AShooterCharacter* NewPawn) { NativeCall<void, AShooterPlayerState*, AShooterCharacter*>(this, "UPrimalPlayerData.ApplyToPlayerCharacter", ForPlayerState, NewPawn); }
    void ApplyPersistentBuffs(AShooterCharacter* NewPawn, AShooterPlayerController* forPC) { NativeCall<void, AShooterCharacter*, AShooterPlayerController*>(this, "UPrimalPlayerData.ApplyPersistentBuffs", NewPawn, forPC); }
    void RefreshPersistentBuffs(AShooterCharacter* theChar) { NativeCall<void, AShooterCharacter*>(this, "UPrimalPlayerData.RefreshPersistentBuffs", theChar); }
    void CreatedNewPlayerData() { NativeCall<void>(this, "UPrimalPlayerData.CreatedNewPlayerData"); }
    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "UPrimalPlayerData.StaticClass"); }
    static void StaticRegisterNativesUPrimalPlayerData() { NativeCall<void>(nullptr, "UPrimalPlayerData.StaticRegisterNativesUPrimalPlayerData"); }
    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "UPrimalPlayerData.GetPrivateStaticClass", Package); }
    void BPAppliedToPlayerState(AShooterPlayerState* ForPlayerState) { NativeCall<void, AShooterPlayerState*>(this, "UPrimalPlayerData.BPAppliedToPlayerState", ForPlayerState); }
    void BPApplyToPlayerCharacter(AShooterPlayerState* ForPlayerState, AShooterCharacter* NewPlayerCharacter) { NativeCall<void, AShooterPlayerState*, AShooterCharacter*>(this, "UPrimalPlayerData.BPApplyToPlayerCharacter", ForPlayerState, NewPlayerCharacter); }
    void BPCreatedNewPlayerData() { NativeCall<void>(this, "UPrimalPlayerData.BPCreatedNewPlayerData"); }
    void BPForceDefeatedBoss(int DifficultyIndex, FName BossName, AShooterPlayerController* PlayerController) { NativeCall<void, int, FName, AShooterPlayerController*>(this, "UPrimalPlayerData.BPForceDefeatedBoss", DifficultyIndex, BossName, PlayerController); }
 
    void SetChibiLevels(int newLevels, AShooterPlayerController* ForPC) { NativeCall<void, int, AShooterPlayerController*>(this, "UPrimalPlayerData.SetChibiLevels", newLevels, ForPC); }
    void GrantGeneralizedAchievementTag(FName ObtainedAchievementTag, AShooterPlayerController* ForPC) { NativeCall<void, FName, AShooterPlayerController*>(this, "UPrimalPlayerData.GrantGeneralizedAchievementTag", ObtainedAchievementTag, ForPC); }
};
 
struct UPrimalCharacterStatusComponent : UActorComponent
{
    FieldArray<float, 12> MaxStatusValuesField() { return { this, "UPrimalCharacterStatusComponent.MaxStatusValues" }; }
    FieldArray<float, 12> BaseLevelMaxStatusValuesField() { return { this, "UPrimalCharacterStatusComponent.BaseLevelMaxStatusValues" }; }
    FieldArray<char, 12> NumberOfLevelUpPointsAppliedField() { return { this, "UPrimalCharacterStatusComponent.NumberOfLevelUpPointsApplied" }; }
    FieldArray<char, 12> NumberOfLevelUpPointsAppliedTamedField() { return { this, "UPrimalCharacterStatusComponent.NumberOfLevelUpPointsAppliedTamed" }; }
    float& TamedIneffectivenessModifierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.TamedIneffectivenessModifier"); }
    float& MovingStaminaRecoveryRateMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.MovingStaminaRecoveryRateMultiplier"); }
    FieldArray<float, 12> RecoveryRateStatusValueField() { return { this, "UPrimalCharacterStatusComponent.RecoveryRateStatusValue" }; }
    FieldArray<float, 12> TimeToRecoverAfterDepletionStatusValueField() { return { this, "UPrimalCharacterStatusComponent.TimeToRecoverAfterDepletionStatusValue" }; }
    FieldArray<float, 12> TimeToRecoverAfterDecreaseStatusValueField() { return { this, "UPrimalCharacterStatusComponent.TimeToRecoverAfterDecreaseStatusValue" }; }
    FieldArray<float, 12> AmountMaxGainedPerLevelUpValueField() { return { this, "UPrimalCharacterStatusComponent.AmountMaxGainedPerLevelUpValue" }; }
    FieldArray<float, 12> AmountMaxGainedPerLevelUpValueTamedField() { return { this, "UPrimalCharacterStatusComponent.AmountMaxGainedPerLevelUpValueTamed" }; }
    FieldArray<char, 12> MaxGainedPerLevelUpValueIsPercentField() { return { this, "UPrimalCharacterStatusComponent.MaxGainedPerLevelUpValueIsPercent" }; }
    FieldArray<char, 12> RecoveryRateIsPercentField() { return { this, "UPrimalCharacterStatusComponent.RecoveryRateIsPercent" }; }
    FieldArray<float, 12> TamingMaxStatMultipliersField() { return { this, "UPrimalCharacterStatusComponent.TamingMaxStatMultipliers" }; }
    FieldArray<float, 12> TamingMaxStatAdditionsField() { return { this, "UPrimalCharacterStatusComponent.TamingMaxStatAdditions" }; }
    FieldArray<float, 12> MaxLevelUpMultiplierField() { return { this, "UPrimalCharacterStatusComponent.MaxLevelUpMultiplier" }; }
    float& TamedLandDinoSwimSpeedLevelUpEffectivenessField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.TamedLandDinoSwimSpeedLevelUpEffectiveness"); }
    float& TamingIneffectivenessMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.TamingIneffectivenessMultiplier"); }
    float& DinoRiderWeightMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.DinoRiderWeightMultiplier"); }
    FieldArray<char, 12> CanLevelUpValueField() { return { this, "UPrimalCharacterStatusComponent.CanLevelUpValue" }; }
    FieldArray<char, 12> DontUseValueField() { return { this, "UPrimalCharacterStatusComponent.DontUseValue" }; }
    FieldArray<FPrimalCharacterStatusStateThresholds, 12> StatusStateThresholdsField() { return { this, "UPrimalCharacterStatusComponent.StatusStateThresholds" }; }
    float& ExperienceAutomaticConsciousIncreaseSpeedField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.ExperienceAutomaticConsciousIncreaseSpeed"); }
    float& CheatMaxWeightField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.CheatMaxWeight"); }
    int& CharacterStatusComponentPriorityField() { return *GetNativePointerField<int*>(this, "UPrimalCharacterStatusComponent.CharacterStatusComponentPriority"); }
    float& SuffocationHealthPercentDecreaseSpeedField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.SuffocationHealthPercentDecreaseSpeed"); }
    float& UnsubmergedOxygenIncreaseSpeedField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.UnsubmergedOxygenIncreaseSpeed"); }
    float& SubmergedOxygenDecreaseSpeedField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.SubmergedOxygenDecreaseSpeed"); }
    float& RunningStaminaConsumptionRateField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.RunningStaminaConsumptionRate"); }
    float& WalkingStaminaConsumptionRateField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.WalkingStaminaConsumptionRate"); }
    float& SwimmingOrFlyingStaminaConsumptionRateField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.SwimmingOrFlyingStaminaConsumptionRate"); }
    float& JumpStaminaConsumptionField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.JumpStaminaConsumption"); }
    float& WindedSpeedModifierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.WindedSpeedModifier"); }
    float& WindedSpeedModifierSwimmingOrFlyingField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.WindedSpeedModifierSwimmingOrFlying"); }
    float& InjuredSpeedModifierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.InjuredSpeedModifier"); }
    float& HypothermicHealthDecreaseRateBaseField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.HypothermicHealthDecreaseRateBase"); }
    float& HypothermicHealthDecreaseRatePerDegreeField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.HypothermicHealthDecreaseRatePerDegree"); }
    float& HyperthermicHealthDecreaseRateBaseField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.HyperthermicHealthDecreaseRateBase"); }
    float& HyperthermicHealthDecreaseRatePerDegreeField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.HyperthermicHealthDecreaseRatePerDegree"); }
    float& XPEarnedPerStaminaConsumedField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.XPEarnedPerStaminaConsumed"); }
    float& KillXPMultiplierPerCharacterLevelField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.KillXPMultiplierPerCharacterLevel"); }
    float& ShareXPWithTribeRangeField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.ShareXPWithTribeRange"); }
    int& BaseCharacterLevelField() { return *GetNativePointerField<int*>(this, "UPrimalCharacterStatusComponent.BaseCharacterLevel"); }
    unsigned __int16& ExtraCharacterLevelField() { return *GetNativePointerField<unsigned __int16*>(this, "UPrimalCharacterStatusComponent.ExtraCharacterLevel"); }
    float& ExperiencePointsField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.ExperiencePoints"); }
    float& ReplicatedExperiencePointsField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.ReplicatedExperiencePoints"); }
    TEnumAsByte<enum ELevelExperienceRampType::Type>& LevelExperienceRampTypeField() { return *GetNativePointerField<TEnumAsByte<enum ELevelExperienceRampType::Type>*>(this, "UPrimalCharacterStatusComponent.LevelExperienceRampType"); }
    float& MaxExperiencePointsField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.MaxExperiencePoints"); }
    float& BaseFoodConsumptionRateField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.BaseFoodConsumptionRate"); }
    float& BaseWaterConsumptionRateField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.BaseWaterConsumptionRate"); }
    float& FortitudeTorpidityDecreaseMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.FortitudeTorpidityDecreaseMultiplier"); }
    float& FortitudeTorpidityIncreaseResistanceField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.FortitudeTorpidityIncreaseResistance"); }
    float& SubmergedWaterIncreaseRateField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.SubmergedWaterIncreaseRate"); }
    float& CrouchedWaterFoodConsumptionMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.CrouchedWaterFoodConsumptionMultiplier"); }
    float& ProneWaterFoodConsumptionMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.ProneWaterFoodConsumptionMultiplier"); }
    float& StaminaRecoveryDecreaseFoodMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.StaminaRecoveryDecreaseFoodMultiplier"); }
    float& StaminaRecoveryDecreaseWaterMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.StaminaRecoveryDecreaseWaterMultiplier"); }
    float& HealthRecoveryDecreaseFoodMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.HealthRecoveryDecreaseFoodMultiplier"); }
    float& BabyDinoConsumingFoodRateMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.BabyDinoConsumingFoodRateMultiplier"); }
    float& DinoTamedAdultConsumingFoodRateMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.DinoTamedAdultConsumingFoodRateMultiplier"); }
    float& BabyGestationConsumingFoodRateMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.BabyGestationConsumingFoodRateMultiplier"); }
    float& BabyDinoStarvationHealthDecreaseRateMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.BabyDinoStarvationHealthDecreaseRateMultiplier"); }
    float& BabyMaxHealthPercentField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.BabyMaxHealthPercent"); }
    float& CrouchedStaminaConsumptionMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.CrouchedStaminaConsumptionMultiplier"); }
    float& ProneStaminaConsumptionMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.ProneStaminaConsumptionMultiplier"); }
    float& StarvationHealthConsumptionRateField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.StarvationHealthConsumptionRate"); }
    float& DehyrdationHealthConsumptionRateField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.DehyrdationHealthConsumptionRate"); }
    float& StaminaConsumptionDecreaseWaterMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.StaminaConsumptionDecreaseWaterMultiplier"); }
    float& StaminaConsumptionDecreaseFoodMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.StaminaConsumptionDecreaseFoodMultiplier"); }
    float& HypothermiaDecreaseFoodMultiplierBaseField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.HypothermiaDecreaseFoodMultiplierBase"); }
    float& HypothermiaDecreaseFoodMultiplierPerDegreeField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.HypothermiaDecreaseFoodMultiplierPerDegree"); }
    float& HyperthermiaDecreaseWaterMultiplierBaseField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.HyperthermiaDecreaseWaterMultiplierBase"); }
    float& HyperthermiaDecreaseWaterMultiplierPerDegreeField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.HyperthermiaDecreaseWaterMultiplierPerDegree"); }
    float& HyperthermiaTemperatureThresholdField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.HyperthermiaTemperatureThreshold"); }
    float& HypothermiaTemperatureThresholdField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.HypothermiaTemperatureThreshold"); }
    float& TorporExitPercentThresholdField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.TorporExitPercentThreshold"); }
    float& KnockedOutTorpidityRecoveryRateMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.KnockedOutTorpidityRecoveryRateMultiplier"); }
    float& DehydrationTorpidityMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.DehydrationTorpidityMultiplier"); }
    float& StarvationTorpidityMultuplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.StarvationTorpidityMultuplier"); }
    float& StarvationTorpidityIncreaseRateField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.StarvationTorpidityIncreaseRate"); }
    float& DehyrdationTorpidityIncreaseRateField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.DehyrdationTorpidityIncreaseRate"); }
    float& InjuredTorpidityIncreaseMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.InjuredTorpidityIncreaseMultiplier"); }
    float& WeightSpeedDecreasePowerField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.WeightSpeedDecreasePower"); }
    float& WeightJumpDecreasePowerField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.WeightJumpDecreasePower"); }
    float& PoopItemMinFoodConsumptionIntervalField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.PoopItemMinFoodConsumptionInterval"); }
    float& PoopItemMaxFoodConsumptionIntervalField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.PoopItemMaxFoodConsumptionInterval"); }
    float& TheMaxTorporIncreasePerBaseLevelField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.TheMaxTorporIncreasePerBaseLevel"); }
    float& CurrentStatusValuesReplicationIntervalField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.CurrentStatusValuesReplicationInterval"); }
    float& InsulationHyperthermiaOffsetExponentField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.InsulationHyperthermiaOffsetExponent"); }
    float& InsulationHyperthermiaOffsetScalerField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.InsulationHyperthermiaOffsetScaler"); }
    float& InsulationHypothermiaOffsetExponentField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.InsulationHypothermiaOffsetExponent"); }
    float& InsulationHypothermiaOffsetScalerField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.InsulationHypothermiaOffsetScaler"); }
    float& HypoCharacterInsulationValueField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.HypoCharacterInsulationValue"); }
    float& HyperCharacterInsulationValueField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.HyperCharacterInsulationValue"); }
    float& PoopItemFoodConsumptionCacheField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.PoopItemFoodConsumptionCache"); }
    float& LastHypothermalCharacterInsulationValueField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.LastHypothermalCharacterInsulationValue"); }
    float& LastHyperthermalCharacterInsulationValueField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.LastHyperthermalCharacterInsulationValue"); }
    TEnumAsByte<enum EPrimalCharacterStatusValue::Type>& MaxStatusValueToAutoUpdateField() { return *GetNativePointerField<TEnumAsByte<enum EPrimalCharacterStatusValue::Type>*>(this, "UPrimalCharacterStatusComponent.MaxStatusValueToAutoUpdate"); }
    float& GenericXPMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.GenericXPMultiplier"); }
    float& CraftEarnXPMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.CraftEarnXPMultiplier"); }
    float& MinInventoryWeightField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.MinInventoryWeight"); }
    float& KillEarnXPMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.KillEarnXPMultiplier"); }
    float& GenericEarnXPMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.GenericEarnXPMultiplier"); }
    float& SpecialEarnXPMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.SpecialEarnXPMultiplier"); }
    float& HarvestEarnXPMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.HarvestEarnXPMultiplier"); }
    float& DefaultHyperthermicInsulationField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.DefaultHyperthermicInsulation"); }
    float& DefaultHypothermicInsulationField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.DefaultHypothermicInsulation"); }
    float& MaxTamingEffectivenessBaseLevelMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.MaxTamingEffectivenessBaseLevelMultiplier"); }
    FString& FoodStatusNameOverrideField() { return *GetNativePointerField<FString*>(this, "UPrimalCharacterStatusComponent.FoodStatusNameOverride"); }
    UTexture2D* FoodStatusIconBackgroundOverrideField() { return *GetNativePointerField<UTexture2D**>(this, "UPrimalCharacterStatusComponent.FoodStatusIconBackgroundOverride"); }
    UTexture2D* FoodStatusIconForegroundOverrideField() { return *GetNativePointerField<UTexture2D**>(this, "UPrimalCharacterStatusComponent.FoodStatusIconForegroundOverride"); }
    TArray<FPrimalCharacterStatusValueModifier>& StatusValueModifiersField() { return *GetNativePointerField<TArray<FPrimalCharacterStatusValueModifier>*>(this, "UPrimalCharacterStatusComponent.StatusValueModifiers"); }
    TArray<unsigned char>& StatusValueModifierDescriptionIndicesField() { return *GetNativePointerField<TArray<unsigned char>*>(this, "UPrimalCharacterStatusComponent.StatusValueModifierDescriptionIndices"); }
    FieldArray<float, 12> CurrentStatusValuesField() { return { this, "UPrimalCharacterStatusComponent.CurrentStatusValues" }; }
    FieldArray<float, 12> AdditionalStatusValuesField() { return { this, "UPrimalCharacterStatusComponent.AdditionalStatusValues" }; }
    FieldArray<float, 12> ReplicatedCurrentStatusValuesField() { return { this, "UPrimalCharacterStatusComponent.ReplicatedCurrentStatusValues" }; }
    FieldArray<float, 12> ReplicatedGlobalMaxStatusValuesField() { return { this, "UPrimalCharacterStatusComponent.ReplicatedGlobalMaxStatusValues" }; }
    FieldArray<float, 12> ReplicatedBaseLevelMaxStatusValuesField() { return { this, "UPrimalCharacterStatusComponent.ReplicatedBaseLevelMaxStatusValues" }; }
    FieldArray<float, 12> ReplicatedGlobalCurrentStatusValuesField() { return { this, "UPrimalCharacterStatusComponent.ReplicatedGlobalCurrentStatusValues" }; }
    FieldArray<char, 12> CurrentStatusStatesField() { return { this, "UPrimalCharacterStatusComponent.CurrentStatusStates" }; }
    FieldArray<long double, 12> LastDecreasedStatusValuesTimesField() { return { this, "UPrimalCharacterStatusComponent.LastDecreasedStatusValuesTimes" }; }
    FieldArray<long double, 12> LastIncreasedStatusValuesTimesField() { return { this, "UPrimalCharacterStatusComponent.LastIncreasedStatusValuesTimes" }; }
    FieldArray<long double, 12> LastMaxedStatusValuesTimesField() { return { this, "UPrimalCharacterStatusComponent.LastMaxedStatusValuesTimes" }; }
    FieldArray<long double, 12> LastDepletedStatusValuesTimesField() { return { this, "UPrimalCharacterStatusComponent.LastDepletedStatusValuesTimes" }; }
    float& StaminaRecoveryExtraResourceDecreaseMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.StaminaRecoveryExtraResourceDecreaseMultiplier"); }
    float& DehydrationStaminaRecoveryRateField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.DehydrationStaminaRecoveryRate"); }
    float& WaterConsumptionMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.WaterConsumptionMultiplier"); }
    float& FoodConsumptionMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.FoodConsumptionMultiplier"); }
    TArray<USoundBase*> EnteredStatusStateSoundsField() { return *GetNativePointerField<TArray<USoundBase*>*>(this, "UPrimalCharacterStatusComponent.EnteredStatusStateSounds"); }
    TArray<USoundBase*> ExitStatusStateSoundsField() { return *GetNativePointerField<TArray<USoundBase*>*>(this, "UPrimalCharacterStatusComponent.ExitStatusStateSounds"); }
    float& ExtraOxygenSpeedStatMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.ExtraOxygenSpeedStatMultiplier"); }
    float& ExtraTamedHealthMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.ExtraTamedHealthMultiplier"); }
    float& WakingTameFoodConsumptionRateMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.WakingTameFoodConsumptionRateMultiplier"); }
    float& SwimmingStaminaRecoveryRateMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.SwimmingStaminaRecoveryRateMultiplier"); }
    float& ExtraWaterConsumptionMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.ExtraWaterConsumptionMultiplier"); }
    float& ExtraFoodConsumptionMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.ExtraFoodConsumptionMultiplier"); }
    float& DefaultMaxOxygenField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.DefaultMaxOxygen"); }
    long double& LastReplicatedCurrentStatusValuesTimeField() { return *GetNativePointerField<long double*>(this, "UPrimalCharacterStatusComponent.LastReplicatedCurrentStatusValuesTime"); }
    float& OriginalMaxTorporField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.OriginalMaxTorpor"); }
    float& MountedDinoDinoWeightMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.MountedDinoDinoWeightMultiplier"); }
    float& ExtraWildDinoDamageMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.ExtraWildDinoDamageMultiplier"); }
    float& ExtraTamedDinoDamageMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.ExtraTamedDinoDamageMultiplier"); }
    float& WeightMultiplierWhenCarriedOrBasedField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.WeightMultiplierWhenCarriedOrBased"); }
    float& WeightMultiplierForCarriedPassengersField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.WeightMultiplierForCarriedPassengers"); }
    float& WeightMultiplierForPlatformPassengersInventoryField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.WeightMultiplierForPlatformPassengersInventory"); }
    FieldArray<float, 12> DinoMaxStatAddMultiplierImprintingField() { return { this, "UPrimalCharacterStatusComponent.DinoMaxStatAddMultiplierImprinting" }; }
    float& DinoImprintingQualityField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.DinoImprintingQuality"); }
    float& TamedBaseHealthMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.TamedBaseHealthMultiplier"); }
    float& ExtraBabyDinoConsumingFoodRateMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.ExtraBabyDinoConsumingFoodRateMultiplier"); }
    TArray<FString>& StatusValueNameOverridesField() { return *GetNativePointerField<TArray<FString>*>(this, "UPrimalCharacterStatusComponent.StatusValueNameOverrides"); }
    TSubclassOf<UDamageType>& RegainOxygenDamageTypeField() { return *GetNativePointerField<TSubclassOf<UDamageType>*>(this, "UPrimalCharacterStatusComponent.RegainOxygenDamageType"); }
    bool& bInWeightLockField() { return *GetNativePointerField<bool*>(this, "UPrimalCharacterStatusComponent.bInWeightLock"); }
    long double& LastReplicatedXPTimeField() { return *GetNativePointerField<long double*>(this, "UPrimalCharacterStatusComponent.LastReplicatedXPTime"); }
    bool& bHasUnlockedMaxPlayerLevelAchievementThisSessionField() { return *GetNativePointerField<bool*>(this, "UPrimalCharacterStatusComponent.bHasUnlockedMaxPlayerLevelAchievementThisSession"); }
    bool& bHasUnlockedMaxDinoLevelAchievementThisSessionField() { return *GetNativePointerField<bool*>(this, "UPrimalCharacterStatusComponent.bHasUnlockedMaxDinoLevelAchievementThisSession"); }
 
    // Bit fields
 
    BitFieldValue<bool, unsigned __int32> bCanSuffocate() { return { this, "UPrimalCharacterStatusComponent.bCanSuffocate" }; }
    BitFieldValue<bool, unsigned __int32> bCanSuffocateIfTamed() { return { this, "UPrimalCharacterStatusComponent.bCanSuffocateIfTamed" }; }
    BitFieldValue<bool, unsigned __int32> bCanGetHungry() { return { this, "UPrimalCharacterStatusComponent.bCanGetHungry" }; }
    BitFieldValue<bool, unsigned __int32> bUseStamina() { return { this, "UPrimalCharacterStatusComponent.bUseStamina" }; }
    BitFieldValue<bool, unsigned __int32> bWalkingConsumesStamina() { return { this, "UPrimalCharacterStatusComponent.bWalkingConsumesStamina" }; }
    BitFieldValue<bool, unsigned __int32> bRunningConsumesStamina() { return { this, "UPrimalCharacterStatusComponent.bRunningConsumesStamina" }; }
    BitFieldValue<bool, unsigned __int32> bConsumeFoodAutomatically() { return { this, "UPrimalCharacterStatusComponent.bConsumeFoodAutomatically" }; }
    BitFieldValue<bool, unsigned __int32> bInfiniteFood() { return { this, "UPrimalCharacterStatusComponent.bInfiniteFood" }; }
    BitFieldValue<bool, unsigned __int32> bAddExperienceAutomatically() { return { this, "UPrimalCharacterStatusComponent.bAddExperienceAutomatically" }; }
    BitFieldValue<bool, unsigned __int32> bConsumeWaterAutomatically() { return { this, "UPrimalCharacterStatusComponent.bConsumeWaterAutomatically" }; }
    BitFieldValue<bool, unsigned __int32> bAutomaticallyUpdateTemperature() { return { this, "UPrimalCharacterStatusComponent.bAutomaticallyUpdateTemperature" }; }
    BitFieldValue<bool, unsigned __int32> bReplicateGlobalStatusValues() { return { this, "UPrimalCharacterStatusComponent.bReplicateGlobalStatusValues" }; }
    BitFieldValue<bool, unsigned __int32> bAllowLevelUps() { return { this, "UPrimalCharacterStatusComponent.bAllowLevelUps" }; }
    BitFieldValue<bool, unsigned __int32> bInfiniteStats() { return { this, "UPrimalCharacterStatusComponent.bInfiniteStats" }; }
    BitFieldValue<bool, unsigned __int32> bAllowSharingXPWithTribe() { return { this, "UPrimalCharacterStatusComponent.bAllowSharingXPWithTribe" }; }
    BitFieldValue<bool, unsigned __int32> bUseStatusSpeedModifiers() { return { this, "UPrimalCharacterStatusComponent.bUseStatusSpeedModifiers" }; }
    BitFieldValue<bool, unsigned __int32> bStatusSpeedModifierOnlyFullOrNone() { return { this, "UPrimalCharacterStatusComponent.bStatusSpeedModifierOnlyFullOrNone" }; }
    BitFieldValue<bool, unsigned __int32> bIgnoreStatusSpeedModifierIfSwimming() { return { this, "UPrimalCharacterStatusComponent.bIgnoreStatusSpeedModifierIfSwimming" }; }
    BitFieldValue<bool, unsigned __int32> bPreventJump() { return { this, "UPrimalCharacterStatusComponent.bPreventJump" }; }
    BitFieldValue<bool, unsigned __int32> bInitializedBaseLevelMaxStatusValues() { return { this, "UPrimalCharacterStatusComponent.bInitializedBaseLevelMaxStatusValues" }; }
    BitFieldValue<bool, unsigned __int32> bInitializedMe() { return { this, "UPrimalCharacterStatusComponent.bInitializedMe" }; }
    BitFieldValue<bool, unsigned __int32> bServerFirstInitialized() { return { this, "UPrimalCharacterStatusComponent.bServerFirstInitialized" }; }
    BitFieldValue<bool, unsigned __int32> bRunningUseDefaultSpeed() { return { this, "UPrimalCharacterStatusComponent.bRunningUseDefaultSpeed" }; }
    BitFieldValue<bool, unsigned __int32> bNeverAllowXP() { return { this, "UPrimalCharacterStatusComponent.bNeverAllowXP" }; }
    BitFieldValue<bool, unsigned __int32> bPreventTamedStatReplication() { return { this, "UPrimalCharacterStatusComponent.bPreventTamedStatReplication" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPAdjustStatusValueModification() { return { this, "UPrimalCharacterStatusComponent.bUseBPAdjustStatusValueModification" }; }
    BitFieldValue<bool, unsigned __int32> bForceDefaultSpeed() { return { this, "UPrimalCharacterStatusComponent.bForceDefaultSpeed" }; }
    BitFieldValue<bool, unsigned __int32> bForceRefreshWeight() { return { this, "UPrimalCharacterStatusComponent.bForceRefreshWeight" }; }
    BitFieldValue<bool, unsigned __int32> bHideFoodStatusFromHUD() { return { this, "UPrimalCharacterStatusComponent.bHideFoodStatusFromHUD" }; }
    BitFieldValue<bool, unsigned __int32> bForceGainOxygen() { return { this, "UPrimalCharacterStatusComponent.bForceGainOxygen" }; }
    BitFieldValue<bool, unsigned __int32> bFreezeStatusValues() { return { this, "UPrimalCharacterStatusComponent.bFreezeStatusValues" }; }
    BitFieldValue<bool, unsigned __int32> bTicked() { return { this, "UPrimalCharacterStatusComponent.bTicked" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPModifyMaxLevel() { return { this, "UPrimalCharacterStatusComponent.bUseBPModifyMaxLevel" }; }
    BitFieldValue<bool, unsigned __int32> bNoStaminaRecoveryWhenStarving() { return { this, "UPrimalCharacterStatusComponent.bNoStaminaRecoveryWhenStarving" }; }
    BitFieldValue<bool, unsigned __int32> bApplyingStatusValueModifiers() { return { this, "UPrimalCharacterStatusComponent.bApplyingStatusValueModifiers" }; }
    BitFieldValue<bool, unsigned __int32> bDontScaleMeleeDamage() { return { this, "UPrimalCharacterStatusComponent.bDontScaleMeleeDamage" }; }
    BitFieldValue<bool, unsigned __int32> bInfiniteWeight() { return { this, "UPrimalCharacterStatusComponent.bInfiniteWeight" }; }
 
    // Functions
 
    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "UPrimalCharacterStatusComponent.StaticClass"); }
    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "UPrimalCharacterStatusComponent.GetLifetimeReplicatedProps", OutLifetimeProps); }
    void InitializeComponent() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.InitializeComponent"); }
    float GetTotalStatusModifierDescriptionIndex(int StatusValueModifierDescriptionIndex) { return NativeCall<float, int>(this, "UPrimalCharacterStatusComponent.GetTotalStatusModifierDescriptionIndex", StatusValueModifierDescriptionIndex); }
    void AddStatusValueModifier(EPrimalCharacterStatusValue::Type ValueType, float Amount, float Speed, bool bContinueOnUnchangedValue, bool bSetValue, int StatusValueModifierDescriptionIndex, bool bResetExistingModifierDescriptionIndex, float LimitExistingModifierDescriptionToMaxAmount, bool bSetAdditionalValue, EPrimalCharacterStatusValue::Type StopAtValueNearMax, bool bMakeUntameable, TSubclassOf<UDamageType> ScaleValueByCharacterDamageType) { NativeCall<void, EPrimalCharacterStatusValue::Type, float, float, bool, bool, int, bool, float, bool, EPrimalCharacterStatusValue::Type, bool, TSubclassOf<UDamageType>>(this, "UPrimalCharacterStatusComponent.AddStatusValueModifier", ValueType, Amount, Speed, bContinueOnUnchangedValue, bSetValue, StatusValueModifierDescriptionIndex, bResetExistingModifierDescriptionIndex, LimitExistingModifierDescriptionToMaxAmount, bSetAdditionalValue, StopAtValueNearMax, bMakeUntameable, ScaleValueByCharacterDamageType); }
    void ApplyStatusValueModifiers(float DeltaTime) { NativeCall<void, float>(this, "UPrimalCharacterStatusComponent.ApplyStatusValueModifiers", DeltaTime); }
    void SetAllStatsToMaximum() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.SetAllStatsToMaximum"); }
    void SetAllStatsToMaximumExcluding(EPrimalCharacterStatusValue::Type exclude) { NativeCall<void, EPrimalCharacterStatusValue::Type>(this, "UPrimalCharacterStatusComponent.SetAllStatsToMaximumExcluding", exclude); }
    void TickStatus(float DeltaTime, bool bForceStatusUpdate) { NativeCall<void, float, bool>(this, "UPrimalCharacterStatusComponent.TickStatus", DeltaTime, bForceStatusUpdate); }
    void UpdateStatusValue(EPrimalCharacterStatusValue::Type valueType, float DeltaTime, bool bManualUpdate) { NativeCall<void, EPrimalCharacterStatusValue::Type, float, bool>(this, "UPrimalCharacterStatusComponent.UpdateStatusValue", valueType, DeltaTime, bManualUpdate); }
    void UpdateWeightStat(bool bForceSetValue) { NativeCall<void, bool>(this, "UPrimalCharacterStatusComponent.UpdateWeightStat", bForceSetValue); }
    void AdjustStatusValueModification(EPrimalCharacterStatusValue::Type valueType, float* Amount, TSubclassOf<UDamageType> DamageTypeClass, bool bManualModification) { NativeCall<void, EPrimalCharacterStatusValue::Type, float*, TSubclassOf<UDamageType>, bool>(this, "UPrimalCharacterStatusComponent.AdjustStatusValueModification", valueType, Amount, DamageTypeClass, bManualModification); }
    void GetDinoFoodConsumptionRateMultiplier(float* Amount) { NativeCall<void, float*>(this, "UPrimalCharacterStatusComponent.GetDinoFoodConsumptionRateMultiplier", Amount); }
    void UninitializeComponent() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.UninitializeComponent"); }
    int GetExtraCharacterLevel() { return NativeCall<int>(this, "UPrimalCharacterStatusComponent.GetExtraCharacterLevel"); }
    void SetExtraCharacterLevel(int NewExtraCharacterLevel) { NativeCall<void, int>(this, "UPrimalCharacterStatusComponent.SetExtraCharacterLevel", NewExtraCharacterLevel); }
    static EPrimalCharacterStatusValue::Type ConvertIntToCharacterStatusEnum(int InInteger) { return NativeCall<EPrimalCharacterStatusValue::Type, int>(nullptr, "UPrimalCharacterStatusComponent.ConvertIntToCharacterStatusEnum", InInteger); }
    float ModifyCurrentStatusValue(EPrimalCharacterStatusValue::Type valueType, float Amount, bool bPercentOfMax, bool bPercentOfCurrent, bool bManualModification, bool bSetValue, TSubclassOf<UDamageType> DamageTypeClass, bool bDamageDontKill, bool bForceSetValue) { return NativeCall<float, EPrimalCharacterStatusValue::Type, float, bool, bool, bool, bool, TSubclassOf<UDamageType>, bool, bool>(this, "UPrimalCharacterStatusComponent.ModifyCurrentStatusValue", valueType, Amount, bPercentOfMax, bPercentOfCurrent, bManualModification, bSetValue, DamageTypeClass, bDamageDontKill, bForceSetValue); }
    void ChangedStatusState(EPrimalCharacterStatusState::Type valueType, bool bEnteredState) { NativeCall<void, EPrimalCharacterStatusState::Type, bool>(this, "UPrimalCharacterStatusComponent.ChangedStatusState", valueType, bEnteredState); }
    void CharacterUpdatedInventory(bool bEquippedOrUneqippedItem) { NativeCall<void, bool>(this, "UPrimalCharacterStatusComponent.CharacterUpdatedInventory", bEquippedOrUneqippedItem); }
    void UpdateInventoryWeight(APrimalCharacter* aPrimalChar) { NativeCall<void, APrimalCharacter*>(this, "UPrimalCharacterStatusComponent.UpdateInventoryWeight", aPrimalChar); }
    void RefreshInsulation() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.RefreshInsulation"); }
    void RescaleMaxStat(EPrimalCharacterStatusValue::Type LevelUpValueType, float TargetValue, bool bIsPercentOfTrueValue) { NativeCall<void, EPrimalCharacterStatusValue::Type, float, bool>(this, "UPrimalCharacterStatusComponent.RescaleMaxStat", LevelUpValueType, TargetValue, bIsPercentOfTrueValue); }
    void RefreshTemperature() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.RefreshTemperature"); }
    void UpdatedCurrentStatusValue(EPrimalCharacterStatusValue::Type valueType, float Amount, bool bManualModification, TSubclassOf<UDamageType> DamageTypeClass, bool bDamageDontKill, bool bDontAdjustOtherStats) { NativeCall<void, EPrimalCharacterStatusValue::Type, float, bool, TSubclassOf<UDamageType>, bool, bool>(this, "UPrimalCharacterStatusComponent.UpdatedCurrentStatusValue", valueType, Amount, bManualModification, DamageTypeClass, bDamageDontKill, bDontAdjustOtherStats); }
    float GetStatusValueRecoveryRate(EPrimalCharacterStatusValue::Type valueType) { return NativeCall<float, EPrimalCharacterStatusValue::Type>(this, "UPrimalCharacterStatusComponent.GetStatusValueRecoveryRate", valueType); }
    float GetRawStatusValueRecoveryRate(EPrimalCharacterStatusValue::Type valueType) { return NativeCall<float, EPrimalCharacterStatusValue::Type>(this, "UPrimalCharacterStatusComponent.GetRawStatusValueRecoveryRate", valueType); }
    void DrawLocalPlayerHUD(AShooterHUD* HUD, float ScaleMult, bool bFromBottomRight) { NativeCall<void, AShooterHUD*, float, bool>(this, "UPrimalCharacterStatusComponent.DrawLocalPlayerHUD", HUD, ScaleMult, bFromBottomRight); }
    void DrawLocalPlayerHUDDescriptions(AShooterHUD* HUD, long double TheTimeSeconds, float ScaleMult, bool bDrawBottomRight) { NativeCall<void, AShooterHUD*, long double, float, bool>(this, "UPrimalCharacterStatusComponent.DrawLocalPlayerHUDDescriptions", HUD, TheTimeSeconds, ScaleMult, bDrawBottomRight); }
    bool IsInStatusState(EPrimalCharacterStatusState::Type StateType) { return NativeCall<bool, EPrimalCharacterStatusState::Type>(this, "UPrimalCharacterStatusComponent.IsInStatusState", StateType); }
    AActor* GetPrimalCharacter() { return NativeCall<AActor*>(this, "UPrimalCharacterStatusComponent.GetPrimalCharacter"); }
    void OnJumped() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.OnJumped"); }
    float GetMeleeDamageModifier() { return NativeCall<float>(this, "UPrimalCharacterStatusComponent.GetMeleeDamageModifier"); }
    float GetCraftingSpeedModifier() { return NativeCall<float>(this, "UPrimalCharacterStatusComponent.GetCraftingSpeedModifier"); }
    float GetMovementSpeedModifier() { return NativeCall<float>(this, "UPrimalCharacterStatusComponent.GetMovementSpeedModifier"); }
    float GetJumpZModifier() { return NativeCall<float>(this, "UPrimalCharacterStatusComponent.GetJumpZModifier"); }
    void OnRep_CurrentStatusValues() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.OnRep_CurrentStatusValues"); }
    void ServerSyncReplicatedValues() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.ServerSyncReplicatedValues"); }
    void OnRep_GlobalCurrentStatusValues() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.OnRep_GlobalCurrentStatusValues"); }
    void OnRep_GlobalMaxStatusValues() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.OnRep_GlobalMaxStatusValues"); }
    void OnRep_GlobalBaseLevelMaxStatusValues() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.OnRep_GlobalBaseLevelMaxStatusValues"); }
    void OnRep_ReplicatedExperiencePoints() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.OnRep_ReplicatedExperiencePoints"); }
    bool CanLevelUp(EPrimalCharacterStatusValue::Type LevelUpValueType, bool bCheckExperience) { return NativeCall<bool, EPrimalCharacterStatusValue::Type, bool>(this, "UPrimalCharacterStatusComponent.CanLevelUp", LevelUpValueType, bCheckExperience); }
    void ServerApplyLevelUp(EPrimalCharacterStatusValue::Type LevelUpValueType, AShooterPlayerController* ByPC) { NativeCall<void, EPrimalCharacterStatusValue::Type, AShooterPlayerController*>(this, "UPrimalCharacterStatusComponent.ServerApplyLevelUp", LevelUpValueType, ByPC); }
    void SetBaseLevel(int Level, bool bDontCurrentSetToMax) { NativeCall<void, int, bool>(this, "UPrimalCharacterStatusComponent.SetBaseLevel", Level, bDontCurrentSetToMax); }
    void SetBaseLevelNoStatChange(int Level) { NativeCall<void, int>(this, "UPrimalCharacterStatusComponent.SetBaseLevelNoStatChange", Level); }
    void SetBaseLevelCustomized(int Level, TArray<FStatValuePair>* CustomBaseStats, TArray<TEnumAsByte<enum EPrimalCharacterStatusValue::Type>>* PrioritizeStats, bool bDontCurrentSetToMax) { NativeCall<void, int, TArray<FStatValuePair>*, TArray<TEnumAsByte<enum EPrimalCharacterStatusValue::Type>>*, bool>(this, "UPrimalCharacterStatusComponent.SetBaseLevelCustomized", Level, CustomBaseStats, PrioritizeStats, bDontCurrentSetToMax); }
    void SetTameable(bool bTameable) { NativeCall<void, bool>(this, "UPrimalCharacterStatusComponent.SetTameable", bTameable); }
    void SetTamed(float TameIneffectivenessModifier, bool bSkipAddingTamedLevels) { NativeCall<void, float, bool>(this, "UPrimalCharacterStatusComponent.SetTamed", TameIneffectivenessModifier, bSkipAddingTamedLevels); }
    void ApplyTamingStatModifiers(float TameIneffectivenessModifier) { NativeCall<void, float>(this, "UPrimalCharacterStatusComponent.ApplyTamingStatModifiers", TameIneffectivenessModifier); }
    bool IsAlignedWithTeam(int TargetingTeam) { return NativeCall<bool, int>(this, "UPrimalCharacterStatusComponent.IsAlignedWithTeam", TargetingTeam); }
    FString* GetStatusValueString(FString* result, EPrimalCharacterStatusValue::Type ValueType, bool bValueOnly) { return NativeCall<FString*, FString*, EPrimalCharacterStatusValue::Type, bool>(this, "UPrimalCharacterStatusComponent.GetStatusValueString", result, ValueType, bValueOnly); }
    FString* GetStatusNameString(FString* result, EPrimalCharacterStatusValue::Type ValueType) { return NativeCall<FString*, FString*, EPrimalCharacterStatusValue::Type>(this, "UPrimalCharacterStatusComponent.GetStatusNameString", result, ValueType); }
    FString* GetStatusMaxValueString(FString* result, EPrimalCharacterStatusValue::Type ValueType, bool bValueOnly) { return NativeCall<FString*, FString*, EPrimalCharacterStatusValue::Type, bool>(this, "UPrimalCharacterStatusComponent.GetStatusMaxValueString", result, ValueType, bValueOnly); }
    int GetCharacterLevel() { return NativeCall<int>(this, "UPrimalCharacterStatusComponent.GetCharacterLevel"); }
    int GetBaseLevelFromLevelUpPoints(bool bIncludePlayerAddedLevels) { return NativeCall<int, bool>(this, "UPrimalCharacterStatusComponent.GetBaseLevelFromLevelUpPoints", bIncludePlayerAddedLevels); }
    void AddExperience(float HowMuch, bool bShareWithTribe, EXPType::Type XPType) { NativeCall<void, float, bool, EXPType::Type>(this, "UPrimalCharacterStatusComponent.AddExperience", HowMuch, bShareWithTribe, XPType); }
    int GetNumLevelUpsAvailable() { return NativeCall<int>(this, "UPrimalCharacterStatusComponent.GetNumLevelUpsAvailable"); }
    float GetExperienceRequiredForNextLevelUp() { return NativeCall<float>(this, "UPrimalCharacterStatusComponent.GetExperienceRequiredForNextLevelUp"); }
    float GetExperienceRequiredForPreviousLevelUp() { return NativeCall<float>(this, "UPrimalCharacterStatusComponent.GetExperienceRequiredForPreviousLevelUp"); }
    bool IsAtMaxLevel() { return NativeCall<bool>(this, "UPrimalCharacterStatusComponent.IsAtMaxLevel"); }
    bool HasExperienceForLevelUp() { return NativeCall<bool>(this, "UPrimalCharacterStatusComponent.HasExperienceForLevelUp"); }
    float GetExperiencePercent() { return NativeCall<float>(this, "UPrimalCharacterStatusComponent.GetExperiencePercent"); }
    void NetSyncMaxStatusValues_Implementation(TArray<float>* NetMaxStatusValues, TArray<float>* NetBaseMaxStatusValues) { NativeCall<void, TArray<float>*, TArray<float>*>(this, "UPrimalCharacterStatusComponent.NetSyncMaxStatusValues_Implementation", NetMaxStatusValues, NetBaseMaxStatusValues); }
    void ClientSyncMaxStatusValues_Implementation(TArray<float>* NetMaxStatusValues, TArray<float>* NetBaseMaxStatusValues) { NativeCall<void, TArray<float>*, TArray<float>*>(this, "UPrimalCharacterStatusComponent.ClientSyncMaxStatusValues_Implementation", NetMaxStatusValues, NetBaseMaxStatusValues); }
    void Serialize(FArchive* Ar) { NativeCall<void, FArchive*>(this, "UPrimalCharacterStatusComponent.Serialize", Ar); }
    bool AllowTaming() { return NativeCall<bool>(this, "UPrimalCharacterStatusComponent.AllowTaming"); }
    void BPDirectSetCurrentStatusValue(EPrimalCharacterStatusValue::Type valueType, float newValue) { NativeCall<void, EPrimalCharacterStatusValue::Type, float>(this, "UPrimalCharacterStatusComponent.BPDirectSetCurrentStatusValue", valueType, newValue); }
    void BPDirectSetMaxStatusValue(EPrimalCharacterStatusValue::Type valueType, float newValue) { NativeCall<void, EPrimalCharacterStatusValue::Type, float>(this, "UPrimalCharacterStatusComponent.BPDirectSetMaxStatusValue", valueType, newValue); }
    float BPGetCurrentStatusValue(EPrimalCharacterStatusValue::Type valueType) { return NativeCall<float, EPrimalCharacterStatusValue::Type>(this, "UPrimalCharacterStatusComponent.BPGetCurrentStatusValue", valueType); }
    float BPGetMaxStatusValue(EPrimalCharacterStatusValue::Type valueType) { return NativeCall<float, EPrimalCharacterStatusValue::Type>(this, "UPrimalCharacterStatusComponent.BPGetMaxStatusValue", valueType); }
    float BPGetPercentStatusValue(EPrimalCharacterStatusValue::Type valueType) { return NativeCall<float, EPrimalCharacterStatusValue::Type>(this, "UPrimalCharacterStatusComponent.BPGetPercentStatusValue", valueType); }
    void SetMaxStatusValue(EPrimalCharacterStatusValue::Type StatType, float newValue) { NativeCall<void, EPrimalCharacterStatusValue::Type, float>(this, "UPrimalCharacterStatusComponent.SetMaxStatusValue", StatType, newValue); }
    void RescaleAllStats() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.RescaleAllStats"); }
    UPrimalCharacterStatusComponent* GetDefaultCharacterStatusComponent() { return NativeCall<UPrimalCharacterStatusComponent*>(this, "UPrimalCharacterStatusComponent.GetDefaultCharacterStatusComponent"); }
    void BPSetRecoveryRateStatusValue(EPrimalCharacterStatusValue::Type valueType, float newValue) { NativeCall<void, EPrimalCharacterStatusValue::Type, float>(this, "UPrimalCharacterStatusComponent.BPSetRecoveryRateStatusValue", valueType, newValue); }
    int GetLevelUpPoints(EPrimalCharacterStatusValue::Type valueType, bool bTamedPoints) { return NativeCall<int, EPrimalCharacterStatusValue::Type, bool>(this, "UPrimalCharacterStatusComponent.GetLevelUpPoints", valueType, bTamedPoints); }
    void SetLevelUpPoints(EPrimalCharacterStatusValue::Type valueType, bool bTamedPoints, int newPoints) { NativeCall<void, EPrimalCharacterStatusValue::Type, bool, int>(this, "UPrimalCharacterStatusComponent.SetLevelUpPoints", valueType, bTamedPoints, newPoints); }
    void ClearAllLevelUpPoints(bool bTamedPoints) { NativeCall<void, bool>(this, "UPrimalCharacterStatusComponent.ClearAllLevelUpPoints", bTamedPoints); }
    void CopyPrimalStatusComponentValues(UPrimalCharacterStatusComponent* src) { NativeCall<void, UPrimalCharacterStatusComponent*>(this, "UPrimalCharacterStatusComponent.CopyPrimalStatusComponentValues", src); }
    FString* GetDebugString(FString* result) { return NativeCall<FString*, FString*>(this, "UPrimalCharacterStatusComponent.GetDebugString", result); }
    static void StaticRegisterNativesUPrimalCharacterStatusComponent() { NativeCall<void>(nullptr, "UPrimalCharacterStatusComponent.StaticRegisterNativesUPrimalCharacterStatusComponent"); }
    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "UPrimalCharacterStatusComponent.GetPrivateStaticClass", Package); }
    float BPAdjustStatusValueModification(EPrimalCharacterStatusValue::Type valueType, float Amount, TSubclassOf<UDamageType> DamageTypeClass, bool bManualModification) { return NativeCall<float, EPrimalCharacterStatusValue::Type, float, TSubclassOf<UDamageType>, bool>(this, "UPrimalCharacterStatusComponent.BPAdjustStatusValueModification", valueType, Amount, DamageTypeClass, bManualModification); }
    float BPModifyMaxExperiencePoints(float InMaxExperiencePoints) { return NativeCall<float, float>(this, "UPrimalCharacterStatusComponent.BPModifyMaxExperiencePoints", InMaxExperiencePoints); }
    int BPModifyMaxLevel(int InMaxLevel) { return NativeCall<int, int>(this, "UPrimalCharacterStatusComponent.BPModifyMaxLevel", InMaxLevel); }
    void ClientSyncMaxStatusValues(TArray<float>* NetMaxStatusValues, TArray<float>* NetBaseMaxStatusValues) { NativeCall<void, TArray<float>*, TArray<float>*>(this, "UPrimalCharacterStatusComponent.ClientSyncMaxStatusValues", NetMaxStatusValues, NetBaseMaxStatusValues); }
    void NetSyncMaxStatusValues(TArray<float>* NetMaxStatusValues, TArray<float>* NetBaseMaxStatusValues) { NativeCall<void, TArray<float>*, TArray<float>*>(this, "UPrimalCharacterStatusComponent.NetSyncMaxStatusValues", NetMaxStatusValues, NetBaseMaxStatusValues); }
};
 
struct APrimalDinoCharacter : APrimalCharacter
{
    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"); }
    FVector & RidingAttackExtraVelocityField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoCharacter.RidingAttackExtraVelocity"); }
    UAnimMontage * StartChargeAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.StartChargeAnimation"); }
    TArray<UAnimMontage*> AttackAnimationsField() { return *GetNativePointerField<TArray<UAnimMontage*>*>(this, "APrimalDinoCharacter.AttackAnimations"); }
    TArray<float> & AttackAnimationWeightsField() { return *GetNativePointerField<TArray<float>*>(this, "APrimalDinoCharacter.AttackAnimationWeights"); }
    TArray<float> & AttackAnimationsTimeFromEndToConsiderFinishedField() { return *GetNativePointerField<TArray<float>*>(this, "APrimalDinoCharacter.AttackAnimationsTimeFromEndToConsiderFinished"); }
    float& ColorizationIntensityField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ColorizationIntensity"); }
    TArray<UMaterialInterface*> FemaleMaterialOverridesField() { return *GetNativePointerField<TArray<UMaterialInterface*>*>(this, "APrimalDinoCharacter.FemaleMaterialOverrides"); }
    float& PaintConsumptionMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.PaintConsumptionMultiplier"); }
    float& ChargingBlockedStopTimeThresholdField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ChargingBlockedStopTimeThreshold"); }
    TArray<FName> & MeleeSwingSocketsField() { return *GetNativePointerField<TArray<FName>*>(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> & AttackInfosField() { return *GetNativePointerField<TArray<FDinoAttackInfo>*>(this, "APrimalDinoCharacter.AttackInfos"); }
    char& CurrentAttackIndexField() { return *GetNativePointerField<char*>(this, "APrimalDinoCharacter.CurrentAttackIndex"); }
    char& LastAttackIndexField() { return *GetNativePointerField<char*>(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"); }
    FVector2D & OverlayTooltipPaddingField() { return *GetNativePointerField<FVector2D*>(this, "APrimalDinoCharacter.OverlayTooltipPadding"); }
    FVector2D & OverlayTooltipScaleField() { return *GetNativePointerField<FVector2D*>(this, "APrimalDinoCharacter.OverlayTooltipScale"); }
    FVector & RiderFPVCameraOffsetField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoCharacter.RiderFPVCameraOffset"); }
    FVector & LandingLocationField() { return *GetNativePointerField<FVector*>(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"); }
    FVector & LastChargeLocationField() { return *GetNativePointerField<FVector*>(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> & NoSaddlePassengerSeatsField() { return *GetNativePointerField<TArray<FSaddlePassengerSeatDefinition>*>(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>> & PassengerPerSeatField() { return *GetNativePointerField<TArray<TWeakObjectPtr<APrimalCharacter>>*>(this, "APrimalDinoCharacter.PassengerPerSeat"); }
    TArray<APrimalCharacter*> SavedPassengerPerSeatField() { return *GetNativePointerField<TArray<APrimalCharacter*>*>(this, "APrimalDinoCharacter.SavedPassengerPerSeat"); }
    TArray<TWeakObjectPtr<APrimalCharacter>> & PrevPassengerPerSeatField() { return *GetNativePointerField<TArray<TWeakObjectPtr<APrimalCharacter>>*>(this, "APrimalDinoCharacter.PrevPassengerPerSeat"); }
    long double& LastClientCameraRotationServerUpdateField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastClientCameraRotationServerUpdate"); }
    TArray<USceneComponent*> OverrideTargetComponentsField() { return *GetNativePointerField<TArray<USceneComponent*>*>(this, "APrimalDinoCharacter.OverrideTargetComponents"); }
    int& LastPlayedAttackAnimationField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.LastPlayedAttackAnimation"); }
    char& AttackIndexOfPlayedAnimationField() { return *GetNativePointerField<char*>(this, "APrimalDinoCharacter.AttackIndexOfPlayedAnimation"); }
    TArray<FDinoBaseLevelWeightEntry> & DinoBaseLevelWeightEntriesField() { return *GetNativePointerField<TArray<FDinoBaseLevelWeightEntry>*>(this, "APrimalDinoCharacter.DinoBaseLevelWeightEntries"); }
    float& OriginalCapsuleHalfHeightField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.OriginalCapsuleHalfHeight"); }
    TArray<FVector> & LastSocketPositionsField() { return *GetNativePointerField<TArray<FVector>*>(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"); }
    FVector & RidingFirstPersonViewLocationOffsetField() { return *GetNativePointerField<FVector*>(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> & HideBoneNamesField() { return *GetNativePointerField<TArray<FName>*>(this, "APrimalDinoCharacter.HideBoneNames"); }
    FString & HideBonesStringField() { return *GetNativePointerField<FString*>(this, "APrimalDinoCharacter.HideBonesString"); }
    FVector & WaterSurfaceExtraJumpVectorField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoCharacter.WaterSurfaceExtraJumpVector"); }
    FVector & FlyerTakeOffAdditionalVelocityField() { return *GetNativePointerField<FVector*>(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"); }
    FVector & TamedWanderHarvestCollectOffsetField() { return *GetNativePointerField<FVector*>(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<char, 6> PreventColorizationRegionsField() { return {this, "APrimalDinoCharacter.PreventColorizationRegions"}; }
    FieldArray<char, 6> AllowPaintingColorRegionsField() { return {this, "APrimalDinoCharacter.AllowPaintingColorRegions"}; }
    FieldArray<char, 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>> & DeathGiveItemClassesField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalItem>>*>(this, "APrimalDinoCharacter.DeathGiveItemClasses"); }
    TArray<float> & DeathGiveItemChanceToBeBlueprintField() { return *GetNativePointerField<TArray<float>*>(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"); }
    FVector & UnboardLocationOffsetField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoCharacter.UnboardLocationOffset"); }
    float& LastTimeWhileHeadingToGoalField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.LastTimeWhileHeadingToGoal"); }
    float& ForceUpdateIKTimerField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ForceUpdateIKTimer"); }
    long double& LastColorizationTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastColorizationTime"); }
    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"); }
    char& TamedAITargetingRangeField() { return *GetNativePointerField<char*>(this, "APrimalDinoCharacter.TamedAITargetingRange"); }
    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"); }
    bool& bUseBPIsValidUnStasisCasterField() { return *GetNativePointerField<bool*>(this, "APrimalDinoCharacter.bUseBPIsValidUnStasisCaster"); }
    TArray<FPrimalSaddleStructure> & SaddleStructuresField() { return *GetNativePointerField<TArray<FPrimalSaddleStructure>*>(this, "APrimalDinoCharacter.SaddleStructures"); }
    int& MaxSaddleStructuresHeightField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.MaxSaddleStructuresHeight"); }
    bool& CalculateStructureHeightFromSaddleField() { return *GetNativePointerField<bool*>(this, "APrimalDinoCharacter.CalculateStructureHeightFromSaddle"); }
    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"); }
    unsigned int& DinoID1Field() { return *GetNativePointerField<unsigned int*>(this, "APrimalDinoCharacter.DinoID1"); }
    unsigned int& DinoID2Field() { return *GetNativePointerField<unsigned int*>(this, "APrimalDinoCharacter.DinoID2"); }
    FRotator & PreviousAimRotField() { return *GetNativePointerField<FRotator*>(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>> & EggItemsToSpawnField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalItem>>*>(this, "APrimalDinoCharacter.EggItemsToSpawn"); }
    TArray<float> & EggWeightsToSpawnField() { return *GetNativePointerField<TArray<float>*>(this, "APrimalDinoCharacter.EggWeightsToSpawn"); }
    TArray<TSubclassOf<UPrimalItem>> & FertilizedEggItemsToSpawnField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalItem>>*>(this, "APrimalDinoCharacter.FertilizedEggItemsToSpawn"); }
    TArray<float> & FertilizedEggWeightsToSpawnField() { return *GetNativePointerField<TArray<float>*>(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<APrimalStructure*> LatchedOnStructuresField() { return *GetNativePointerField<TArray<APrimalStructure*>*>(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& 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> & StepDamageFootDamageSocketsField() { return *GetNativePointerField<TArray<FName>*>(this, "APrimalDinoCharacter.StepDamageFootDamageSockets"); }
    float& DurationBeforeMovingStuckPawnField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.DurationBeforeMovingStuckPawn"); }
    FVector & LastCheckedLocationField() { return *GetNativePointerField<FVector*>(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*> StartledAnimationsField() { return *GetNativePointerField<TArray<UAnimMontage*>*>(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& CorpseLifespanNonRelevantField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.CorpseLifespanNonRelevant"); }
    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"); }
    FVector & FloatingHUDTextWorldOffsetField() { return *GetNativePointerField<FVector*>(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"); }
    FRotator & DinoAimRotationOffsetField() { return *GetNativePointerField<FRotator*>(this, "APrimalDinoCharacter.DinoAimRotationOffset"); }
    long double& LastDinoAllyLookInterpTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastDinoAllyLookInterpTime"); }
    FVector & LastRiderOverlappedPositionField() { return *GetNativePointerField<FVector*>(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"); }
    FVector & RiderCheckTraceOffsetField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoCharacter.RiderCheckTraceOffset"); }
    FVector & RiderEjectionImpulseField() { return *GetNativePointerField<FVector*>(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*> WildAmbientHarvestingAnimationsField() { return *GetNativePointerField<TArray<UAnimMontage*>*>(this, "APrimalDinoCharacter.WildAmbientHarvestingAnimations"); }
    TArray<TSubclassOf<UPrimalHarvestingComponent>> & WildAmbientHarvestingComponentClassesField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalHarvestingComponent>>*>(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> & OverrideBaseStatLevelsOnSpawnField() { return *GetNativePointerField<TArray<FStatValuePair>*>(this, "APrimalDinoCharacter.OverrideBaseStatLevelsOnSpawn"); }
    TArray<TEnumAsByte<enum EPrimalCharacterStatusValue::Type>> & OverrideStatPriorityOnSpawnField() { return *GetNativePointerField<TArray<TEnumAsByte<enum EPrimalCharacterStatusValue::Type>>*>(this, "APrimalDinoCharacter.OverrideStatPriorityOnSpawn"); }
    TSubclassOf<UDamageType> & TamedHarvestDamageTypeField() { return *GetNativePointerField<TSubclassOf<UDamageType>*>(this, "APrimalDinoCharacter.TamedHarvestDamageType"); }
    FDinoSaddleStruct & SaddleStructField() { return *GetNativePointerField<FDinoSaddleStruct*>(this, "APrimalDinoCharacter.SaddleStruct"); }
    TArray<APrimalCharacter*> DraggedRagdollsField() { return *GetNativePointerField<TArray<APrimalCharacter*>*>(this, "APrimalDinoCharacter.DraggedRagdolls"); }
    FVector & LastOverrodeRandomWanderLocationField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoCharacter.LastOverrodeRandomWanderLocation"); }
    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*> SaddledStructuresField() { return *GetNativePointerField<TArray<APrimalStructure*>*>(this, "APrimalDinoCharacter.SaddledStructures"); }
    TSubclassOf<APrimalBuff> & BuffGivenToBasedCharactersField() { return *GetNativePointerField<TSubclassOf<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<char, 12> GestationEggNumberOfLevelUpPointsAppliedField() { return {this, "APrimalDinoCharacter.GestationEggNumberOfLevelUpPointsApplied"}; }
    float& GestationEggTamedIneffectivenessModifierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.GestationEggTamedIneffectivenessModifier"); }
    FieldArray<char, 6> GestationEggColorSetIndicesField() { return {this, "APrimalDinoCharacter.GestationEggColorSetIndices"}; }
    float& NewFemaleMinTimeBetweenMatingField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.NewFemaleMinTimeBetweenMating"); }
    float& NewFemaleMaxTimeBetweenMatingField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.NewFemaleMaxTimeBetweenMating"); }
    TArray<TSubclassOf<APrimalBuff>> & DefaultTamedBuffsField() { return *GetNativePointerField<TArray<TSubclassOf<APrimalBuff>>*>(this, "APrimalDinoCharacter.DefaultTamedBuffs"); }
    FVector & InterpolatedVelocityField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoCharacter.InterpolatedVelocity"); }
    FVector & OldInterpolatedLocationField() { return *GetNativePointerField<FVector*>(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"); }
    FVector & LastGangCheckPositionField() { return *GetNativePointerField<FVector*>(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> & FPVRiderBoneNamesToHideField() { return *GetNativePointerField<TArray<FName>*>(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"); }
    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"); }
    FVector & RiderAttackLocationField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoCharacter.RiderAttackLocation"); }
    char& TribeGroupPetOrderingRankField() { return *GetNativePointerField<char*>(this, "APrimalDinoCharacter.TribeGroupPetOrderingRank"); }
    char& TribeGroupPetRidingRankField() { return *GetNativePointerField<char*>(this, "APrimalDinoCharacter.TribeGroupPetRidingRank"); }
    char& FollowStoppingDistanceField() { return *GetNativePointerField<char*>(this, "APrimalDinoCharacter.FollowStoppingDistance"); }
    FString & ImprinterNameField() { return *GetNativePointerField<FString*>(this, "APrimalDinoCharacter.ImprinterName"); }
    unsigned __int64& ImprinterPlayerDataIDField() { return *GetNativePointerField<unsigned __int64*>(this, "APrimalDinoCharacter.ImprinterPlayerDataID"); }
    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"); }
    FVector & BabyCuddleWalkStartingLocationField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoCharacter.BabyCuddleWalkStartingLocation"); }
    long double& BabyNextCuddleTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.BabyNextCuddleTime"); }
    TEnumAsByte<enum EBabyCuddleType::Type> & BabyCuddleTypeField() { return *GetNativePointerField<TEnumAsByte<enum EBabyCuddleType::Type>*>(this, "APrimalDinoCharacter.BabyCuddleType"); }
    TSubclassOf<UPrimalItem> & BabyCuddleFoodField() { return *GetNativePointerField<TSubclassOf<UPrimalItem>*>(this, "APrimalDinoCharacter.BabyCuddleFood"); }
    UAnimMontage * BabyCuddledAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalDinoCharacter.BabyCuddledAnimation"); }
    TArray<TSubclassOf<UPrimalItem>> & MyBabyCuddleFoodTypesField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalItem>>*>(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& 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"); }
    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"); }
    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"); }
    FRotator & LastRiderMountedWeaponRotationField() { return *GetNativePointerField<FRotator*>(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"); }
    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> & DinoAncestorsField() { return *GetNativePointerField<TArray<FDinoAncestorsEntry>*>(this, "APrimalDinoCharacter.DinoAncestors"); }
    TArray<FDinoAncestorsEntry> & DinoAncestorsMaleField() { return *GetNativePointerField<TArray<FDinoAncestorsEntry>*>(this, "APrimalDinoCharacter.DinoAncestorsMale"); }
    TArray<FDinoAncestorsEntry> & NextBabyDinoAncestorsField() { return *GetNativePointerField<TArray<FDinoAncestorsEntry>*>(this, "APrimalDinoCharacter.NextBabyDinoAncestors"); }
    TArray<FDinoAncestorsEntry> & NextBabyDinoAncestorsMaleField() { return *GetNativePointerField<TArray<FDinoAncestorsEntry>*>(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> & DinoExtraDefaultInventoryItemsField() { return *GetNativePointerField<TArray<FDinoExtraDefaultItemList>*>(this, "APrimalDinoCharacter.DinoExtraDefaultInventoryItems"); }
    TArray<TSubclassOf<UPrimalItem>> & DeathGiveEngramClassesField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalItem>>*>(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>> & DamageVictimClassesIgnoreBlockingGeomtryTraceField() { return *GetNativePointerField<TArray<TSubclassOf<AActor>>*>(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 & NonDedicatedFreezeDinoPhysicsIfLevelUnloadedField() { return *GetNativePointerField<FName*>(this, "APrimalDinoCharacter.NonDedicatedFreezeDinoPhysicsIfLevelUnloaded"); }
    TArray<FName> & NonDedicatedFreezeWildDinoPhysicsIfLevelsUnloadedField() { return *GetNativePointerField<TArray<FName>*>(this, "APrimalDinoCharacter.NonDedicatedFreezeWildDinoPhysicsIfLevelsUnloaded"); }
    FVector & UnboardLocationTraceOffsetField() { return *GetNativePointerField<FVector*>(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"); }
    char& CurrentPassengerSeatIndexField() { return *GetNativePointerField<char*>(this, "APrimalDinoCharacter.CurrentPassengerSeatIndex"); }
    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"); }
    TArray<TSubclassOf<UPrimalItem>> & ForceAllowFoodAsConsumableListField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalItem>>*>(this, "APrimalDinoCharacter.ForceAllowFoodAsConsumableList"); }
 
    // Bit fields
 
    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" }; }
    BitFieldValue<bool, unsigned __int32> bAllowCarryCharacterWithoutRider() { return { this, "APrimalDinoCharacter.bAllowCarryCharacterWithoutRider" }; }
    BitFieldValue<bool, unsigned __int32> bWildDinoPreventWeight() { return { this, "APrimalDinoCharacter.bWildDinoPreventWeight" }; }
    BitFieldValue<bool, unsigned __int32> bDebugMeleeAttacks() { return { this, "APrimalDinoCharacter.bDebugMeleeAttacks" }; }
    BitFieldValue<bool, unsigned __int32> bRetainCarriedCharacterOnDismount() { return { this, "APrimalDinoCharacter.bRetainCarriedCharacterOnDismount" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOnTamedProcessOrder() { return { this, "APrimalDinoCharacter.bUseBPOnTamedProcessOrder" }; }
    BitFieldValue<bool, unsigned __int32> bUseBP_OnTamedOrderReceived() { return { this, "APrimalDinoCharacter.bUseBP_OnTamedOrderReceived" }; }
    BitFieldValue<bool, unsigned __int32> bAllowAttackWithCryoSickness() { return { this, "APrimalDinoCharacter.bAllowAttackWithCryoSickness" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPCanCryo() { return { this, "APrimalDinoCharacter.bUseBPCanCryo" }; }
    BitFieldValue<bool, unsigned __int32> bWildPreventTeleporting() { return { this, "APrimalDinoCharacter.bWildPreventTeleporting" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPClampMaxHarvestHealth() { return { this, "APrimalDinoCharacter.bUseBPClampMaxHarvestHealth" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPCheckCanSpawnFromLocation() { return { this, "APrimalDinoCharacter.bUseBPCheckCanSpawnFromLocation" }; }
    BitFieldValue<bool, unsigned __int32> bIsLanding() { return { this, "APrimalDinoCharacter.bIsLanding" }; }
    BitFieldValue<bool, unsigned __int32> bCanCharge() { return { this, "APrimalDinoCharacter.bCanCharge" }; }
    BitFieldValue<bool, unsigned __int32> bCancelInterpolation() { return { this, "APrimalDinoCharacter.bCancelInterpolation" }; }
    BitFieldValue<bool, unsigned __int32> bIsCharging() { return { this, "APrimalDinoCharacter.bIsCharging" }; }
    BitFieldValue<bool, unsigned __int32> bChargeDamageStructures() { return { this, "APrimalDinoCharacter.bChargeDamageStructures" }; }
    BitFieldValue<bool, unsigned __int32> bReplicatePitchWhileSwimming() { return { this, "APrimalDinoCharacter.bReplicatePitchWhileSwimming" }; }
    BitFieldValue<bool, unsigned __int32> bIsFlying() { return { this, "APrimalDinoCharacter.bIsFlying" }; }
    BitFieldValue<bool, unsigned __int32> bIsWakingTame() { return { this, "APrimalDinoCharacter.bIsWakingTame" }; }
    BitFieldValue<bool, unsigned __int32> bAllowRiding() { return { this, "APrimalDinoCharacter.bAllowRiding" }; }
    BitFieldValue<bool, unsigned __int32> bForceAutoTame() { return { this, "APrimalDinoCharacter.bForceAutoTame" }; }
    BitFieldValue<bool, unsigned __int32> bRiderJumpTogglesFlight() { return { this, "APrimalDinoCharacter.bRiderJumpTogglesFlight" }; }
    BitFieldValue<bool, unsigned __int32> bHasRider() { return { this, "APrimalDinoCharacter.bHasRider" }; }
    BitFieldValue<bool, unsigned __int32> bAllowCarryFlyerDinos() { return { this, "APrimalDinoCharacter.bAllowCarryFlyerDinos" }; }
    BitFieldValue<bool, unsigned __int32> bForcedLanding() { return { this, "APrimalDinoCharacter.bForcedLanding" }; }
    BitFieldValue<bool, unsigned __int32> bFlyerForceNoPitch() { return { this, "APrimalDinoCharacter.bFlyerForceNoPitch" }; }
    BitFieldValue<bool, unsigned __int32> bFlyerForceLimitPitch() { return { this, "APrimalDinoCharacter.bFlyerForceLimitPitch" }; }
    BitFieldValue<bool, unsigned __int32> bPreventStasis() { return { this, "APrimalDinoCharacter.bPreventStasis" }; }
    BitFieldValue<bool, unsigned __int32> bAutoTameable() { return { this, "APrimalDinoCharacter.bAutoTameable" }; }
    BitFieldValue<bool, unsigned __int32> bAlwaysSetTamingTeamOnItemAdd() { return { this, "APrimalDinoCharacter.bAlwaysSetTamingTeamOnItemAdd" }; }
    BitFieldValue<bool, unsigned __int32> bDinoLoadedFromSaveGame() { return { this, "APrimalDinoCharacter.bDinoLoadedFromSaveGame" }; }
    BitFieldValue<bool, unsigned __int32> bCheatForceTameRide() { return { this, "APrimalDinoCharacter.bCheatForceTameRide" }; }
    BitFieldValue<bool, unsigned __int32> bIsFemale() { return { this, "APrimalDinoCharacter.bIsFemale" }; }
    BitFieldValue<bool, unsigned __int32> bRiderUseDirectionalAttackIndex() { return { this, "APrimalDinoCharacter.bRiderUseDirectionalAttackIndex" }; }
    BitFieldValue<bool, unsigned __int32> bCanBeTamed() { return { this, "APrimalDinoCharacter.bCanBeTamed" }; }
    BitFieldValue<bool, unsigned __int32> bTargetingIgnoredByWildDinos() { return { this, "APrimalDinoCharacter.bTargetingIgnoredByWildDinos" }; }
    BitFieldValue<bool, unsigned __int32> bTargetingIgnoreWildDinos() { return { this, "APrimalDinoCharacter.bTargetingIgnoreWildDinos" }; }
    BitFieldValue<bool, unsigned __int32> bCanMountOnHumans() { return { this, "APrimalDinoCharacter.bCanMountOnHumans" }; }
    BitFieldValue<bool, unsigned __int32> bIKIgnoreSaddleStructures() { return { this, "APrimalDinoCharacter.bIKIgnoreSaddleStructures" }; }
    BitFieldValue<bool, unsigned __int32> bAttackTargetWhenLaunched() { return { this, "APrimalDinoCharacter.bAttackTargetWhenLaunched" }; }
    BitFieldValue<bool, unsigned __int32> bCanOpenLockedDoors() { return { this, "APrimalDinoCharacter.bCanOpenLockedDoors" }; }
    BitFieldValue<bool, unsigned __int32> bUseColorization() { return { this, "APrimalDinoCharacter.bUseColorization" }; }
    BitFieldValue<bool, unsigned __int32> bMeleeSwingDamageBlockedByStrutures() { return { this, "APrimalDinoCharacter.bMeleeSwingDamageBlockedByStrutures" }; }
    BitFieldValue<bool, unsigned __int32> bAllowTargetingCorpses() { return { this, "APrimalDinoCharacter.bAllowTargetingCorpses" }; }
    BitFieldValue<bool, unsigned __int32> bRiderDontRequireSaddle() { return { this, "APrimalDinoCharacter.bRiderDontRequireSaddle" }; }
    BitFieldValue<bool, unsigned __int32> bAllowsFishingOnSaddle() { return { this, "APrimalDinoCharacter.bAllowsFishingOnSaddle" }; }
    BitFieldValue<bool, unsigned __int32> bCanBeOrdered() { return { this, "APrimalDinoCharacter.bCanBeOrdered" }; }
    BitFieldValue<bool, unsigned __int32> bOverridePlatformStructureLimit() { return { this, "APrimalDinoCharacter.bOverridePlatformStructureLimit" }; }
    BitFieldValue<bool, unsigned __int32> bMeleeAttackHarvetUsableComponents() { return { this, "APrimalDinoCharacter.bMeleeAttackHarvetUsableComponents" }; }
    BitFieldValue<bool, unsigned __int32> bPlatformSaddleIgnoreRotDotCheck() { return { this, "APrimalDinoCharacter.bPlatformSaddleIgnoreRotDotCheck" }; }
    BitFieldValue<bool, unsigned __int32> bUseInteprolatedVelocity() { return { this, "APrimalDinoCharacter.bUseInteprolatedVelocity" }; }
    BitFieldValue<bool, unsigned __int32> bIsCarnivore() { return { this, "APrimalDinoCharacter.bIsCarnivore" }; }
    BitFieldValue<bool, unsigned __int32> bAllowRidingInWater() { return { this, "APrimalDinoCharacter.bAllowRidingInWater" }; }
    BitFieldValue<bool, unsigned __int32> bUsesGender() { return { this, "APrimalDinoCharacter.bUsesGender" }; }
    BitFieldValue<bool, unsigned __int32> bTargetEverything() { return { this, "APrimalDinoCharacter.bTargetEverything" }; }
    BitFieldValue<bool, unsigned __int32> bTamedWanderHarvestNonUsableHarvesting() { return { this, "APrimalDinoCharacter.bTamedWanderHarvestNonUsableHarvesting" }; }
    BitFieldValue<bool, unsigned __int32> bEnableTamedWandering() { return { this, "APrimalDinoCharacter.bEnableTamedWandering" }; }
    BitFieldValue<bool, unsigned __int32> bEnableTamedMating() { return { this, "APrimalDinoCharacter.bEnableTamedMating" }; }
    BitFieldValue<bool, unsigned __int32> bCollectVictimItems() { return { this, "APrimalDinoCharacter.bCollectVictimItems" }; }
    BitFieldValue<bool, unsigned __int32> bServerInitializedDino() { return { this, "APrimalDinoCharacter.bServerInitializedDino" }; }
    BitFieldValue<bool, unsigned __int32> bNPCSpawnerOverrideLevel() { return { this, "APrimalDinoCharacter.bNPCSpawnerOverrideLevel" }; }
    BitFieldValue<bool, unsigned __int32> bHasMateBoost() { return { this, "APrimalDinoCharacter.bHasMateBoost" }; }
    BitFieldValue<bool, unsigned __int32> NPCSpawnerAddLevelOffsetBeforeMultiplier() { return { this, "APrimalDinoCharacter.NPCSpawnerAddLevelOffsetBeforeMultiplier" }; }
    BitFieldValue<bool, unsigned __int32> bTamingHasFood() { return { this, "APrimalDinoCharacter.bTamingHasFood" }; }
    BitFieldValue<bool, unsigned __int32> bDontWander() { return { this, "APrimalDinoCharacter.bDontWander" }; }
    BitFieldValue<bool, unsigned __int32> bAnimIsMoving() { return { this, "APrimalDinoCharacter.bAnimIsMoving" }; }
    BitFieldValue<bool, unsigned __int32> bDoStepDamage() { return { this, "APrimalDinoCharacter.bDoStepDamage" }; }
    BitFieldValue<bool, unsigned __int32> bPreventBasingWhenUntamed() { return { this, "APrimalDinoCharacter.bPreventBasingWhenUntamed" }; }
    BitFieldValue<bool, unsigned __int32> bForceAlwaysAllowBasing() { return { this, "APrimalDinoCharacter.bForceAlwaysAllowBasing" }; }
    BitFieldValue<bool, unsigned __int32> bChargingRequiresWalking() { return { this, "APrimalDinoCharacter.bChargingRequiresWalking" }; }
    BitFieldValue<bool, unsigned __int32> bUseRootLocSwimOffset() { return { this, "APrimalDinoCharacter.bUseRootLocSwimOffset" }; }
    BitFieldValue<bool, unsigned __int32> bUseLowQualityAnimationTick() { return { this, "APrimalDinoCharacter.bUseLowQualityAnimationTick" }; }
    BitFieldValue<bool, unsigned __int32> bDisplaySummonedNotification() { return { this, "APrimalDinoCharacter.bDisplaySummonedNotification" }; }
    BitFieldValue<bool, unsigned __int32> bDisplayKilledNotification() { return { this, "APrimalDinoCharacter.bDisplayKilledNotification" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPGetAttackWeight() { return { this, "APrimalDinoCharacter.bUseBPGetAttackWeight" }; }
    BitFieldValue<bool, unsigned __int32> bServerForceUpdateDinoGameplayMeshNearPlayer() { return { this, "APrimalDinoCharacter.bServerForceUpdateDinoGameplayMeshNearPlayer" }; }
    BitFieldValue<bool, unsigned __int32> bPreventAllRiderWeapons() { return { this, "APrimalDinoCharacter.bPreventAllRiderWeapons" }; }
    BitFieldValue<bool, unsigned __int32> bPreventAllRiderWeaponsOnReequip() { return { this, "APrimalDinoCharacter.bPreventAllRiderWeaponsOnReequip" }; }
    BitFieldValue<bool, unsigned __int32> bAllowDeathAutoGrab() { return { this, "APrimalDinoCharacter.bAllowDeathAutoGrab" }; }
    BitFieldValue<bool, unsigned __int32> bSupportWakingTame() { return { this, "APrimalDinoCharacter.bSupportWakingTame" }; }
    BitFieldValue<bool, unsigned __int32> bAllowAutoUnstasisDestroy() { return { this, "APrimalDinoCharacter.bAllowAutoUnstasisDestroy" }; }
    BitFieldValue<bool, unsigned __int32> bDebugBaby() { return { this, "APrimalDinoCharacter.bDebugBaby" }; }
    BitFieldValue<bool, unsigned __int32> bAlwaysUpdateAimOffsetInterpolation() { return { this, "APrimalDinoCharacter.bAlwaysUpdateAimOffsetInterpolation" }; }
    BitFieldValue<bool, unsigned __int32> WildAmbientHarvestingAnimationServerTickPose() { return { this, "APrimalDinoCharacter.WildAmbientHarvestingAnimationServerTickPose" }; }
    BitFieldValue<bool, unsigned __int32> bPreventSleepingTame() { return { this, "APrimalDinoCharacter.bPreventSleepingTame" }; }
    BitFieldValue<bool, unsigned __int32> bTamedWanderHarvest() { return { this, "APrimalDinoCharacter.bTamedWanderHarvest" }; }
    BitFieldValue<bool, unsigned __int32> bSimulatedNetLandCheckFloor() { return { this, "APrimalDinoCharacter.bSimulatedNetLandCheckFloor" }; }
    BitFieldValue<bool, unsigned __int32> bRefreshedColorization() { return { this, "APrimalDinoCharacter.bRefreshedColorization" }; }
    BitFieldValue<bool, unsigned __int32> bPoopIsEgg() { return { this, "APrimalDinoCharacter.bPoopIsEgg" }; }
    BitFieldValue<bool, unsigned __int32> bPoopIsDud() { return { this, "APrimalDinoCharacter.bPoopIsDud" }; }
    BitFieldValue<bool, unsigned __int32> bWasChargingBlocked() { return { this, "APrimalDinoCharacter.bWasChargingBlocked" }; }
    BitFieldValue<bool, unsigned __int32> bWasRidingFalling() { return { this, "APrimalDinoCharacter.bWasRidingFalling" }; }
    BitFieldValue<bool, unsigned __int32> bInitializedForReplicatedBasing() { return { this, "APrimalDinoCharacter.bInitializedForReplicatedBasing" }; }
    BitFieldValue<bool, unsigned __int32> bClientWasTamed() { return { this, "APrimalDinoCharacter.bClientWasTamed" }; }
    BitFieldValue<bool, unsigned __int32> bFlyerPreventRiderAutoFly() { return { this, "APrimalDinoCharacter.bFlyerPreventRiderAutoFly" }; }
    BitFieldValue<bool, unsigned __int32> bAllowFlyerLandedRider() { return { this, "APrimalDinoCharacter.bAllowFlyerLandedRider" }; }
    BitFieldValue<bool, unsigned __int32> bPreventFlyerFlyingRider() { return { this, "APrimalDinoCharacter.bPreventFlyerFlyingRider" }; }
    BitFieldValue<bool, unsigned __int32> bPreventFlyerCapsuleExpansion() { return { this, "APrimalDinoCharacter.bPreventFlyerCapsuleExpansion" }; }
    BitFieldValue<bool, unsigned __int32> bIncludeCarryWeightOfBasedPawns() { return { this, "APrimalDinoCharacter.bIncludeCarryWeightOfBasedPawns" }; }
    BitFieldValue<bool, unsigned __int32> bForceRiderNetworkParent() { return { this, "APrimalDinoCharacter.bForceRiderNetworkParent" }; }
    BitFieldValue<bool, unsigned __int32> bForcePerfectTame() { return { this, "APrimalDinoCharacter.bForcePerfectTame" }; }
    BitFieldValue<bool, unsigned __int32> bCanHaveBaby() { return { this, "APrimalDinoCharacter.bCanHaveBaby" }; }
    BitFieldValue<bool, unsigned __int32> bUseBabyGestation() { return { this, "APrimalDinoCharacter.bUseBabyGestation" }; }
    BitFieldValue<bool, unsigned __int32> bPreventUnalignedDinoBasing() { return { this, "APrimalDinoCharacter.bPreventUnalignedDinoBasing" }; }
    BitFieldValue<bool, unsigned __int32> bOverrideLevelMusicIfTamed() { return { this, "APrimalDinoCharacter.bOverrideLevelMusicIfTamed" }; }
    BitFieldValue<bool, unsigned __int32> bReachedMaxStructures() { return { this, "APrimalDinoCharacter.bReachedMaxStructures" }; }
    BitFieldValue<bool, unsigned __int32> bSupportsSaddleStructures() { return { this, "APrimalDinoCharacter.bSupportsSaddleStructures" }; }
    BitFieldValue<bool, unsigned __int32> bBonesHidden() { return { this, "APrimalDinoCharacter.bBonesHidden" }; }
    BitFieldValue<bool, unsigned __int32> bDelayedAttachement() { return { this, "APrimalDinoCharacter.bDelayedAttachement" }; }
    BitFieldValue<bool, unsigned __int32> bCanBeRepaired() { return { this, "APrimalDinoCharacter.bCanBeRepaired" }; }
    BitFieldValue<bool, unsigned __int32> bFlyerDontAutoLandOnDismount() { return { this, "APrimalDinoCharacter.bFlyerDontAutoLandOnDismount" }; }
    BitFieldValue<bool, unsigned __int32> bIsRepairing() { return { this, "APrimalDinoCharacter.bIsRepairing" }; }
    BitFieldValue<bool, unsigned __int32> bIsBaby() { return { this, "APrimalDinoCharacter.bIsBaby" }; }
    BitFieldValue<bool, unsigned __int32> bWasBaby() { return { this, "APrimalDinoCharacter.bWasBaby" }; }
    BitFieldValue<bool, unsigned __int32> bCanUnclaimTame() { return { this, "APrimalDinoCharacter.bCanUnclaimTame" }; }
    BitFieldValue<bool, unsigned __int32> bAllowWildDinoEquipment() { return { this, "APrimalDinoCharacter.bAllowWildDinoEquipment" }; }
    BitFieldValue<bool, unsigned __int32> bUseTamedVisibleComponents() { return { this, "APrimalDinoCharacter.bUseTamedVisibleComponents" }; }
    BitFieldValue<bool, unsigned __int32> bAllowDemolish() { return { this, "APrimalDinoCharacter.bAllowDemolish" }; }
    BitFieldValue<bool, unsigned __int32> bUseGang() { return { this, "APrimalDinoCharacter.bUseGang" }; }
    BitFieldValue<bool, unsigned __int32> bBlueprintDrawFloatingHUD() { return { this, "APrimalDinoCharacter.bBlueprintDrawFloatingHUD" }; }
    BitFieldValue<bool, unsigned __int32> bEggBoosted() { return { this, "APrimalDinoCharacter.bEggBoosted" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPTamedTick() { return { this, "APrimalDinoCharacter.bUseBPTamedTick" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOverrideWantsToRun() { return { this, "APrimalDinoCharacter.bUseBPOverrideWantsToRun" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPPlayDying() { return { this, "APrimalDinoCharacter.bUseBPPlayDying" }; }
    BitFieldValue<bool, unsigned __int32> bSupportsPassengerSeats() { return { this, "APrimalDinoCharacter.bSupportsPassengerSeats" }; }
    BitFieldValue<bool, unsigned __int32> bAddPassengerSeatMultiUseEntries() { return { this, "APrimalDinoCharacter.bAddPassengerSeatMultiUseEntries" }; }
    BitFieldValue<bool, unsigned __int32> bUseSaddlePassengerSeatsWhenAvailable() { return { this, "APrimalDinoCharacter.bUseSaddlePassengerSeatsWhenAvailable" }; }
    BitFieldValue<bool, unsigned __int32> bScaleInsulationByMeleeDamage() { return { this, "APrimalDinoCharacter.bScaleInsulationByMeleeDamage" }; }
    BitFieldValue<bool, unsigned __int32> bInventoryOnlyAllowCraftingWhenWandering() { return { this, "APrimalDinoCharacter.bInventoryOnlyAllowCraftingWhenWandering" }; }
    BitFieldValue<bool, unsigned __int32> bUseWildRandomScale() { return { this, "APrimalDinoCharacter.bUseWildRandomScale" }; }
    BitFieldValue<bool, unsigned __int32> bHeldJumpSlowFalling() { return { this, "APrimalDinoCharacter.bHeldJumpSlowFalling" }; }
    BitFieldValue<bool, unsigned __int32> bIsHeldJumpSlowFalling() { return { this, "APrimalDinoCharacter.bIsHeldJumpSlowFalling" }; }
    BitFieldValue<bool, unsigned __int32> bPlayingSlowFallingAnim() { return { this, "APrimalDinoCharacter.bPlayingSlowFallingAnim" }; }
    BitFieldValue<bool, unsigned __int32> bTriggerBPUnstasis() { return { this, "APrimalDinoCharacter.bTriggerBPUnstasis" }; }
    BitFieldValue<bool, unsigned __int32> bWildProduceEggDynamically() { return { this, "APrimalDinoCharacter.bWildProduceEggDynamically" }; }
    BitFieldValue<bool, unsigned __int32> bPreventWakingTameFeeding() { return { this, "APrimalDinoCharacter.bPreventWakingTameFeeding" }; }
    BitFieldValue<bool, unsigned __int32> bForceDisablingTaming() { return { this, "APrimalDinoCharacter.bForceDisablingTaming" }; }
    BitFieldValue<bool, unsigned __int32> bFlyerAllowRidingInCaves() { return { this, "APrimalDinoCharacter.bFlyerAllowRidingInCaves" }; }
    BitFieldValue<bool, unsigned __int32> bScaleExtraRunningSpeedModifier() { return { this, "APrimalDinoCharacter.bScaleExtraRunningSpeedModifier" }; }
    BitFieldValue<bool, unsigned __int32> bOverrideCrosshairAlpha() { return { this, "APrimalDinoCharacter.bOverrideCrosshairAlpha" }; }
    BitFieldValue<bool, unsigned __int32> bOverrideCrosshairColor() { return { this, "APrimalDinoCharacter.bOverrideCrosshairColor" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPGetCrosshairLocation() { return { this, "APrimalDinoCharacter.bUseBPGetCrosshairLocation" }; }
    BitFieldValue<bool, unsigned __int32> bCenterOffscreenFloatingHUDWidgets() { return { this, "APrimalDinoCharacter.bCenterOffscreenFloatingHUDWidgets" }; }
    BitFieldValue<bool, unsigned __int32> bClampOffscreenFloatingHUDWidgets() { return { this, "APrimalDinoCharacter.bClampOffscreenFloatingHUDWidgets" }; }
    BitFieldValue<bool, unsigned __int32> bUseFixedSpawnLevel() { return { this, "APrimalDinoCharacter.bUseFixedSpawnLevel" }; }
    BitFieldValue<bool, unsigned __int32> bTreatCrouchInputAsAttack() { return { this, "APrimalDinoCharacter.bTreatCrouchInputAsAttack" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPGetRiderUnboardLocation() { return { this, "APrimalDinoCharacter.bUseBPGetRiderUnboardLocation" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPGetRiderUnboardDirection() { return { this, "APrimalDinoCharacter.bUseBPGetRiderUnboardDirection" }; }
    BitFieldValue<bool, unsigned __int32> bUniqueDino() { return { this, "APrimalDinoCharacter.bUniqueDino" }; }
    BitFieldValue<bool, unsigned __int32> bModifyBasedCamera() { return { this, "APrimalDinoCharacter.bModifyBasedCamera" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOnRefreshColorization() { return { this, "APrimalDinoCharacter.bUseBPOnRefreshColorization" }; }
    BitFieldValue<bool, unsigned __int32> bHideAncestorsButton() { return { this, "APrimalDinoCharacter.bHideAncestorsButton" }; }
    BitFieldValue<bool, unsigned __int32> bUseBP_OverrideDinoName() { return { this, "APrimalDinoCharacter.bUseBP_OverrideDinoName" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPDinoTooltipCustomProgressBar() { return { this, "APrimalDinoCharacter.bUseBPDinoTooltipCustomProgressBar" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPDisplayTamedMessage() { return { this, "APrimalDinoCharacter.bUseBPDisplayTamedMessage" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOverrideTamingDescriptionLabel() { return { this, "APrimalDinoCharacter.bUseBPOverrideTamingDescriptionLabel" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPCanMountOnCharacter() { return { this, "APrimalDinoCharacter.bUseBPCanMountOnCharacter" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPGetRiderSocket() { return { this, "APrimalDinoCharacter.bUseBPGetRiderSocket" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPShowTamingPanel() { return { this, "APrimalDinoCharacter.bUseBPShowTamingPanel" }; }
    BitFieldValue<bool, unsigned __int32> bMeleeSwingDamageBlockedByAllStationaryObjects() { return { this, "APrimalDinoCharacter.bMeleeSwingDamageBlockedByAllStationaryObjects" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPChargingModifyInputAcceleration() { return { this, "APrimalDinoCharacter.bUseBPChargingModifyInputAcceleration" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOnRepIsCharging() { return { this, "APrimalDinoCharacter.bUseBPOnRepIsCharging" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPPreventOrderAllowed() { return { this, "APrimalDinoCharacter.bUseBPPreventOrderAllowed" }; }
    BitFieldValue<bool, unsigned __int32> bPassengerDinosUsePassengerAnim() { return { this, "APrimalDinoCharacter.bPassengerDinosUsePassengerAnim" }; }
    BitFieldValue<bool, unsigned __int32> bUsesPassengerAnimOnDinos() { return { this, "APrimalDinoCharacter.bUsesPassengerAnimOnDinos" }; }
    BitFieldValue<bool, unsigned __int32> bOverrideRotationOnCarriedCharacter() { return { this, "APrimalDinoCharacter.bOverrideRotationOnCarriedCharacter" }; }
    BitFieldValue<bool, unsigned __int32> bAdvancedCarryRelease() { return { this, "APrimalDinoCharacter.bAdvancedCarryRelease" }; }
    BitFieldValue<bool, unsigned __int32> bForceCarriedPlayerToCheckForWalls() { return { this, "APrimalDinoCharacter.bForceCarriedPlayerToCheckForWalls" }; }
    BitFieldValue<bool, unsigned __int32> bClearRiderOnDinoImmobilized() { return { this, "APrimalDinoCharacter.bClearRiderOnDinoImmobilized" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPIsBasedOnActor() { return { this, "APrimalDinoCharacter.bUseBPIsBasedOnActor" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPUnstasisConsumeFood() { return { this, "APrimalDinoCharacter.bUseBPUnstasisConsumeFood" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOnDinoStartled() { return { this, "APrimalDinoCharacter.bUseBPOnDinoStartled" }; }
    BitFieldValue<bool, unsigned __int32> bSimulateRootMotion() { return { this, "APrimalDinoCharacter.bSimulateRootMotion" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOverrideStencilAllianceForTarget() { return { this, "APrimalDinoCharacter.bUseBPOverrideStencilAllianceForTarget" }; }
    BitFieldValue<bool, unsigned __int32> bDisableHighQualityAIVolumeLedgeChecking() { return { this, "APrimalDinoCharacter.bDisableHighQualityAIVolumeLedgeChecking" }; }
    BitFieldValue<bool, unsigned __int32> bDoHighQualityLedgeChecking() { return { this, "APrimalDinoCharacter.bDoHighQualityLedgeChecking" }; }
    BitFieldValue<bool, unsigned __int32> bOnlyDoStepDamageWhenRunning() { return { this, "APrimalDinoCharacter.bOnlyDoStepDamageWhenRunning" }; }
    BitFieldValue<bool, unsigned __int32> bShouldNotifyClientWhenLanded() { return { this, "APrimalDinoCharacter.bShouldNotifyClientWhenLanded" }; }
    BitFieldValue<bool, unsigned __int32> bPreventPlatformSaddleMultiFloors() { return { this, "APrimalDinoCharacter.bPreventPlatformSaddleMultiFloors" }; }
    BitFieldValue<bool, unsigned __int32> bPreventMountedDinoMeshHiding() { return { this, "APrimalDinoCharacter.bPreventMountedDinoMeshHiding" }; }
    BitFieldValue<bool, unsigned __int32> bUsePlayerMountedCarryingDinoAnimation() { return { this, "APrimalDinoCharacter.bUsePlayerMountedCarryingDinoAnimation" }; }
    BitFieldValue<bool, unsigned __int32> bPreventRotationRateModifier() { return { this, "APrimalDinoCharacter.bPreventRotationRateModifier" }; }
    BitFieldValue<bool, unsigned __int32> bStepDamageFoliageOnly() { return { this, "APrimalDinoCharacter.bStepDamageFoliageOnly" }; }
    BitFieldValue<bool, unsigned __int32> bPreventUntamedRun() { return { this, "APrimalDinoCharacter.bPreventUntamedRun" }; }
    BitFieldValue<bool, unsigned __int32> bAllowTogglingPublicSeating() { return { this, "APrimalDinoCharacter.bAllowTogglingPublicSeating" }; }
    BitFieldValue<bool, unsigned __int32> bAllowPublicSeating() { return { this, "APrimalDinoCharacter.bAllowPublicSeating" }; }
    BitFieldValue<bool, unsigned __int32> bAllowWaterSurfaceExtraJump() { return { this, "APrimalDinoCharacter.bAllowWaterSurfaceExtraJump" }; }
    BitFieldValue<bool, unsigned __int32> bUseVelocityForRequestedMoveIfStuck() { return { this, "APrimalDinoCharacter.bUseVelocityForRequestedMoveIfStuck" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPDoAttack() { return { this, "APrimalDinoCharacter.bUseBPDoAttack" }; }
    BitFieldValue<bool, unsigned __int32> bStepDamageNonFoliageWithoutRunning() { return { this, "APrimalDinoCharacter.bStepDamageNonFoliageWithoutRunning" }; }
    BitFieldValue<bool, unsigned __int32> bStepDamageAllTargetables() { return { this, "APrimalDinoCharacter.bStepDamageAllTargetables" }; }
    BitFieldValue<bool, unsigned __int32> bDamageNonFoliageFeetSocketsOnly() { return { this, "APrimalDinoCharacter.bDamageNonFoliageFeetSocketsOnly" }; }
    BitFieldValue<bool, unsigned __int32> bRiderDontBeBlockedByPawnMesh() { return { this, "APrimalDinoCharacter.bRiderDontBeBlockedByPawnMesh" }; }
    BitFieldValue<bool, unsigned __int32> bUseExtendedUnstasisCheck() { return { this, "APrimalDinoCharacter.bUseExtendedUnstasisCheck" }; }
    BitFieldValue<bool, unsigned __int32> bTickedStasis() { return { this, "APrimalDinoCharacter.bTickedStasis" }; }
    BitFieldValue<bool, unsigned __int32> bAllowDinoAutoConsumeInventoryFood() { return { this, "APrimalDinoCharacter.bAllowDinoAutoConsumeInventoryFood" }; }
    BitFieldValue<bool, unsigned __int32> bForceNoCharacterStatusComponentTick() { return { this, "APrimalDinoCharacter.bForceNoCharacterStatusComponentTick" }; }
    BitFieldValue<bool, unsigned __int32> bIsRaidDino() { return { this, "APrimalDinoCharacter.bIsRaidDino" }; }
    BitFieldValue<bool, unsigned __int32> bWildIgnoredByAutoTurrets() { return { this, "APrimalDinoCharacter.bWildIgnoredByAutoTurrets" }; }
    BitFieldValue<bool, unsigned __int32> bWildAllowTargetingNeutralStructures() { return { this, "APrimalDinoCharacter.bWildAllowTargetingNeutralStructures" }; }
    BitFieldValue<bool, unsigned __int32> bDoStepDamageTamedOnly() { return { this, "APrimalDinoCharacter.bDoStepDamageTamedOnly" }; }
    BitFieldValue<bool, unsigned __int32> bStepDamageNonFoliageTamedOnly() { return { this, "APrimalDinoCharacter.bStepDamageNonFoliageTamedOnly" }; }
    BitFieldValue<bool, unsigned __int32> bDroppedInventoryDeposit() { return { this, "APrimalDinoCharacter.bDroppedInventoryDeposit" }; }
    BitFieldValue<bool, unsigned __int32> bForceWildDeathInventoryDeposit() { return { this, "APrimalDinoCharacter.bForceWildDeathInventoryDeposit" }; }
    BitFieldValue<bool, unsigned __int32> bIsCarryingCharacter() { return { this, "APrimalDinoCharacter.bIsCarryingCharacter" }; }
    BitFieldValue<bool, unsigned __int32> bIsCarryingPassenger() { return { this, "APrimalDinoCharacter.bIsCarryingPassenger" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPCanTakePassenger() { return { this, "APrimalDinoCharacter.bUseBPCanTakePassenger" }; }
    BitFieldValue<bool, unsigned __int32> bIsManualFoodEat() { return { this, "APrimalDinoCharacter.bIsManualFoodEat" }; }
    BitFieldValue<bool, unsigned __int32> bDontPlayAttackingMusic() { return { this, "APrimalDinoCharacter.bDontPlayAttackingMusic" }; }
    BitFieldValue<bool, unsigned __int32> bForceIgnoreRagdollHarvesting() { return { this, "APrimalDinoCharacter.bForceIgnoreRagdollHarvesting" }; }
    BitFieldValue<bool, unsigned __int32> bBPModifyAimOffsetTargetLocation() { return { this, "APrimalDinoCharacter.bBPModifyAimOffsetTargetLocation" }; }
    BitFieldValue<bool, unsigned __int32> bBPModifyAimOffsetNoTarget() { return { this, "APrimalDinoCharacter.bBPModifyAimOffsetNoTarget" }; }
    BitFieldValue<bool, unsigned __int32> bIsVehicle() { return { this, "APrimalDinoCharacter.bIsVehicle" }; }
    BitFieldValue<bool, unsigned __int32> bDisallowPostNetReplication() { return { this, "APrimalDinoCharacter.bDisallowPostNetReplication" }; }
    BitFieldValue<bool, unsigned __int32> bTakingOff() { return { this, "APrimalDinoCharacter.bTakingOff" }; }
    BitFieldValue<bool, unsigned __int32> bPreventMating() { return { this, "APrimalDinoCharacter.bPreventMating" }; }
    BitFieldValue<bool, unsigned __int32> bAttackStopsRotation() { return { this, "APrimalDinoCharacter.bAttackStopsRotation" }; }
    BitFieldValue<bool, unsigned __int32> bFlyerDinoAllowBackwardsFlight() { return { this, "APrimalDinoCharacter.bFlyerDinoAllowBackwardsFlight" }; }
    BitFieldValue<bool, unsigned __int32> bFlyerDinoAllowStrafing() { return { this, "APrimalDinoCharacter.bFlyerDinoAllowStrafing" }; }
    BitFieldValue<bool, unsigned __int32> bIgnoreTargetingLiveUnriddenDinos() { return { this, "APrimalDinoCharacter.bIgnoreTargetingLiveUnriddenDinos" }; }
    BitFieldValue<bool, unsigned __int32> bSleepedForceCreateInventory() { return { this, "APrimalDinoCharacter.bSleepedForceCreateInventory" }; }
    BitFieldValue<bool, unsigned __int32> bLocalForceNearbySkelMeshUpdate() { return { this, "APrimalDinoCharacter.bLocalForceNearbySkelMeshUpdate" }; }
    BitFieldValue<bool, unsigned __int32> bFlyerDisableEnemyTargetingMaxDeltaZ() { return { this, "APrimalDinoCharacter.bFlyerDisableEnemyTargetingMaxDeltaZ" }; }
    BitFieldValue<bool, unsigned __int32> bIsBossDino() { return { this, "APrimalDinoCharacter.bIsBossDino" }; }
    BitFieldValue<bool, unsigned __int32> bTamedAIAllowSpecialAttacks() { return { this, "APrimalDinoCharacter.bTamedAIAllowSpecialAttacks" }; }
    BitFieldValue<bool, unsigned __int32> bTamedAIToggleSpecialAttacks() { return { this, "APrimalDinoCharacter.bTamedAIToggleSpecialAttacks" }; }
    BitFieldValue<bool, unsigned __int32> bLocalPrimaryAttackPressed() { return { this, "APrimalDinoCharacter.bLocalPrimaryAttackPressed" }; }
    BitFieldValue<bool, unsigned __int32> bRepeatPrimaryAttack() { return { this, "APrimalDinoCharacter.bRepeatPrimaryAttack" }; }
    BitFieldValue<bool, unsigned __int32> bPreventUploading() { return { this, "APrimalDinoCharacter.bPreventUploading" }; }
    BitFieldValue<bool, unsigned __int32> bPreventHibernation() { return { this, "APrimalDinoCharacter.bPreventHibernation" }; }
    BitFieldValue<bool, unsigned __int32> bRiderMovementLocked() { return { this, "APrimalDinoCharacter.bRiderMovementLocked" }; }
    BitFieldValue<bool, unsigned __int32> bTameTimerSet() { return { this, "APrimalDinoCharacter.bTameTimerSet" }; }
    BitFieldValue<bool, unsigned __int32> bNeutered() { return { this, "APrimalDinoCharacter.bNeutered" }; }
    BitFieldValue<bool, unsigned __int32> bIgnoreAllWhistles() { return { this, "APrimalDinoCharacter.bIgnoreAllWhistles" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPDoHarvestAttack() { return { this, "APrimalDinoCharacter.bUseBPDoHarvestAttack" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPModifyHarvestingQuantity() { return { this, "APrimalDinoCharacter.bUseBPModifyHarvestingQuantity" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPModifyHarvestingWeightsArray() { return { this, "APrimalDinoCharacter.bUseBPModifyHarvestingWeightsArray" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPModifyHarvestDamage() { return { this, "APrimalDinoCharacter.bUseBPModifyHarvestDamage" }; }
    BitFieldValue<bool, unsigned __int32> bHideFloatingHUD() { return { this, "APrimalDinoCharacter.bHideFloatingHUD" }; }
    BitFieldValue<bool, unsigned __int32> bDisableHarvesting() { return { this, "APrimalDinoCharacter.bDisableHarvesting" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPDinoPostBeginPlay() { return { this, "APrimalDinoCharacter.bUseBPDinoPostBeginPlay" }; }
    BitFieldValue<bool, unsigned __int32> bForceAllowTickingThisFrame() { return { this, "APrimalDinoCharacter.bForceAllowTickingThisFrame" }; }
    BitFieldValue<bool, unsigned __int32> bFlyerDontGainImpulseOnSubmerged() { return { this, "APrimalDinoCharacter.bFlyerDontGainImpulseOnSubmerged" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPCanAutodrag() { return { this, "APrimalDinoCharacter.bUseBPCanAutodrag" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPCanDragCharacter() { return { this, "APrimalDinoCharacter.bUseBPCanDragCharacter" }; }
    BitFieldValue<bool, unsigned __int32> bAllowDraggingWhileFalling() { return { this, "APrimalDinoCharacter.bAllowDraggingWhileFalling" }; }
    BitFieldValue<bool, unsigned __int32> bSingleplayerFreezePhysicsWhenNoTarget() { return { this, "APrimalDinoCharacter.bSingleplayerFreezePhysicsWhenNoTarget" }; }
    BitFieldValue<bool, unsigned __int32> bIsSingleplayer() { return { this, "APrimalDinoCharacter.bIsSingleplayer" }; }
    BitFieldValue<bool, unsigned __int32> bIsCloneDino() { return { this, "APrimalDinoCharacter.bIsCloneDino" }; }
    BitFieldValue<bool, unsigned __int32> bUseAdvancedAnimLerp() { return { this, "APrimalDinoCharacter.bUseAdvancedAnimLerp" }; }
    BitFieldValue<bool, unsigned __int32> bPreventWanderingUnderWater() { return { this, "APrimalDinoCharacter.bPreventWanderingUnderWater" }; }
    BitFieldValue<bool, unsigned __int32> bWildAllowFollowTamedTarget() { return { this, "APrimalDinoCharacter.bWildAllowFollowTamedTarget" }; }
    BitFieldValue<bool, unsigned __int32> bAllowDamageSameTeamAndClass() { return { this, "APrimalDinoCharacter.bAllowDamageSameTeamAndClass" }; }
    BitFieldValue<bool, unsigned __int32> bAllowsTurretMode() { return { this, "APrimalDinoCharacter.bAllowsTurretMode" }; }
    BitFieldValue<bool, unsigned __int32> bAllowRidingInTurretMode() { return { this, "APrimalDinoCharacter.bAllowRidingInTurretMode" }; }
    BitFieldValue<bool, unsigned __int32> bIsInTurretMode() { return { this, "APrimalDinoCharacter.bIsInTurretMode" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPShouldCancelDoAttack() { return { this, "APrimalDinoCharacter.bUseBPShouldCancelDoAttack" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPModifyDesiredRotation() { return { this, "APrimalDinoCharacter.bUseBPModifyDesiredRotation" }; }
    BitFieldValue<bool, unsigned __int32> bUseLocalSpaceDesiredRotationWithRider() { return { this, "APrimalDinoCharacter.bUseLocalSpaceDesiredRotationWithRider" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPDesiredRotationIsLocalSpace() { return { this, "APrimalDinoCharacter.bUseBPDesiredRotationIsLocalSpace" }; }
    BitFieldValue<bool, unsigned __int32> bForcedLandingClearRider() { return { this, "APrimalDinoCharacter.bForcedLandingClearRider" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOverrideCameraViewTarget() { return { this, "APrimalDinoCharacter.bUseBPOverrideCameraViewTarget" }; }
    BitFieldValue<bool, unsigned __int32> bIsRobot() { return { this, "APrimalDinoCharacter.bIsRobot" }; }
    BitFieldValue<bool, unsigned __int32> bUseBP_CustomModifier_RotationRate() { return { this, "APrimalDinoCharacter.bUseBP_CustomModifier_RotationRate" }; }
    BitFieldValue<bool, unsigned __int32> bUseBP_CustomModifier_MaxSpeed() { return { this, "APrimalDinoCharacter.bUseBP_CustomModifier_MaxSpeed" }; }
    BitFieldValue<bool, unsigned __int32> bUseBP_OnStartLandingNotify() { return { this, "APrimalDinoCharacter.bUseBP_OnStartLandingNotify" }; }
    BitFieldValue<bool, unsigned __int32> bIsClearingRider() { return { this, "APrimalDinoCharacter.bIsClearingRider" }; }
    BitFieldValue<bool, unsigned __int32> bUseAttackForceWalkDistanceMultiplier() { return { this, "APrimalDinoCharacter.bUseAttackForceWalkDistanceMultiplier" }; }
    BitFieldValue<bool, unsigned __int32> bForcePerFrameTicking() { return { this, "APrimalDinoCharacter.bForcePerFrameTicking" }; }
    BitFieldValue<bool, unsigned __int32> bHadStaticBase() { return { this, "APrimalDinoCharacter.bHadStaticBase" }; }
    BitFieldValue<bool, unsigned __int32> bNoKillXP() { return { this, "APrimalDinoCharacter.bNoKillXP" }; }
    BitFieldValue<bool, unsigned __int32> bIgnoreAllyLook() { return { this, "APrimalDinoCharacter.bIgnoreAllyLook" }; }
    BitFieldValue<bool, unsigned __int32> bBabyInitiallyUnclaimed() { return { this, "APrimalDinoCharacter.bBabyInitiallyUnclaimed" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPForceTurretFastTargeting() { return { this, "APrimalDinoCharacter.bUseBPForceTurretFastTargeting" }; }
    BitFieldValue<bool, unsigned __int32> bLastAnyLegOnGround() { return { this, "APrimalDinoCharacter.bLastAnyLegOnGround" }; }
    BitFieldValue<bool, unsigned __int32> bSuppressWakingTameMessage() { return { this, "APrimalDinoCharacter.bSuppressWakingTameMessage" }; }
    BitFieldValue<bool, unsigned __int32> bPreventFlyerLanding() { return { this, "APrimalDinoCharacter.bPreventFlyerLanding" }; }
    BitFieldValue<bool, unsigned __int32> bHasDied() { return { this, "APrimalDinoCharacter.bHasDied" }; }
    BitFieldValue<bool, unsigned __int32> bHasPlayDying() { return { this, "APrimalDinoCharacter.bHasPlayDying" }; }
    BitFieldValue<bool, unsigned __int32> bDisableCollisionWithDinosWhenFlying() { return { this, "APrimalDinoCharacter.bDisableCollisionWithDinosWhenFlying" }; }
    BitFieldValue<bool, unsigned __int32> bAllowTrapping() { return { this, "APrimalDinoCharacter.bAllowTrapping" }; }
    BitFieldValue<bool, unsigned __int32> bPreventWildTrapping() { return { this, "APrimalDinoCharacter.bPreventWildTrapping" }; }
    BitFieldValue<bool, unsigned __int32> bIsTrapTamed() { return { this, "APrimalDinoCharacter.bIsTrapTamed" }; }
    BitFieldValue<bool, unsigned __int32> bIgnoreDestroyOnRapidDeath() { return { this, "APrimalDinoCharacter.bIgnoreDestroyOnRapidDeath" }; }
    BitFieldValue<bool, unsigned __int32> bPreventFallingBumpCheck() { return { this, "APrimalDinoCharacter.bPreventFallingBumpCheck" }; }
    BitFieldValue<bool, unsigned __int32> bIsDestroyingDino() { return { this, "APrimalDinoCharacter.bIsDestroyingDino" }; }
    BitFieldValue<bool, unsigned __int32> bCheckBPAllowClaiming() { return { this, "APrimalDinoCharacter.bCheckBPAllowClaiming" }; }
    BitFieldValue<bool, unsigned __int32> bUseBlueprintExtraBabyScale() { return { this, "APrimalDinoCharacter.bUseBlueprintExtraBabyScale" }; }
    BitFieldValue<bool, unsigned __int32> bPreventNeuter() { return { this, "APrimalDinoCharacter.bPreventNeuter" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPGetDragSocketName() { return { this, "APrimalDinoCharacter.bUseBPGetDragSocketName" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPGetDragSocketDinoName() { return { this, "APrimalDinoCharacter.bUseBPGetDragSocketDinoName" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPGetLookOffsetSocketName() { return { this, "APrimalDinoCharacter.bUseBPGetLookOffsetSocketName" }; }
    BitFieldValue<bool, unsigned __int32> bTargetEverythingIncludingSameTeamInPVE() { return { this, "APrimalDinoCharacter.bTargetEverythingIncludingSameTeamInPVE" }; }
    BitFieldValue<bool, unsigned __int32> bForceUsePhysicalFootSurfaceTrace() { return { this, "APrimalDinoCharacter.bForceUsePhysicalFootSurfaceTrace" }; }
    BitFieldValue<bool, unsigned __int32> bUseBP_OnPostNetReplication() { return { this, "APrimalDinoCharacter.bUseBP_OnPostNetReplication" }; }
    BitFieldValue<bool, unsigned __int32> bPassiveFlee() { return { this, "APrimalDinoCharacter.bPassiveFlee" }; }
    BitFieldValue<bool, unsigned __int32> bDidAllowTickingTickingThisFrame() { return { this, "APrimalDinoCharacter.bDidAllowTickingTickingThisFrame" }; }
    BitFieldValue<bool, unsigned __int32> bOnlyTargetConscious() { return { this, "APrimalDinoCharacter.bOnlyTargetConscious" }; }
    BitFieldValue<bool, unsigned __int32> bBPManagedFPVViewLocationNoRider() { return { this, "APrimalDinoCharacter.bBPManagedFPVViewLocationNoRider" }; }
    BitFieldValue<bool, unsigned __int32> bHideSaddleInFPV() { return { this, "APrimalDinoCharacter.bHideSaddleInFPV" }; }
    BitFieldValue<bool, unsigned __int32> bPreventCloning() { return { this, "APrimalDinoCharacter.bPreventCloning" }; }
    BitFieldValue<bool, unsigned __int32> bPreventStasisOnDedi() { return { this, "APrimalDinoCharacter.bPreventStasisOnDedi" }; }
    BitFieldValue<bool, unsigned __int32> bAlwaysCheckForFloor() { return { this, "APrimalDinoCharacter.bAlwaysCheckForFloor" }; }
    BitFieldValue<bool, unsigned __int32> bAlwaysCheckForFalling() { return { this, "APrimalDinoCharacter.bAlwaysCheckForFalling" }; }
    BitFieldValue<bool, unsigned __int32> bForceAllowCarryWaterDinos() { return { this, "APrimalDinoCharacter.bForceAllowCarryWaterDinos" }; }
    BitFieldValue<bool, unsigned __int32> bUseBP_AllowWalkableSlopeOverride() { return { this, "APrimalDinoCharacter.bUseBP_AllowWalkableSlopeOverride" }; }
    BitFieldValue<bool, unsigned __int32> bUseBP_CanFly() { return { this, "APrimalDinoCharacter.bUseBP_CanFly" }; }
    BitFieldValue<bool, unsigned __int32> bUseBP_OverrideBasedCharactersCameraInterpSpeed() { return { this, "APrimalDinoCharacter.bUseBP_OverrideBasedCharactersCameraInterpSpeed" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOverrideFloatingHUDLocation() { return { this, "APrimalDinoCharacter.bUseBPOverrideFloatingHUDLocation" }; }
    BitFieldValue<bool, unsigned __int32> bInterceptPlayerEmotes() { return { this, "APrimalDinoCharacter.bInterceptPlayerEmotes" }; }
    BitFieldValue<bool, unsigned __int32> bUseBP_ShouldPreventBasedCharactersCameraInterpolation() { return { this, "APrimalDinoCharacter.bUseBP_ShouldPreventBasedCharactersCameraInterpolation" }; }
    BitFieldValue<bool, unsigned __int32> bRidingIsSeperateUnstasisCaster() { return { this, "APrimalDinoCharacter.bRidingIsSeperateUnstasisCaster" }; }
    BitFieldValue<bool, unsigned __int32> bIsOceanManagerDino() { return { this, "APrimalDinoCharacter.bIsOceanManagerDino" }; }
    BitFieldValue<bool, unsigned __int32> DisableCameraShakes() { return { this, "APrimalDinoCharacter.DisableCameraShakes" }; }
    BitFieldValue<bool, unsigned __int32> bUseBP_OverrideCarriedCharacterTransform() { return { this, "APrimalDinoCharacter.bUseBP_OverrideCarriedCharacterTransform" }; }
    BitFieldValue<bool, unsigned __int32> bUseBP_OnBasedPawnNotifies() { return { this, "APrimalDinoCharacter.bUseBP_OnBasedPawnNotifies" }; }
    BitFieldValue<bool, unsigned __int32> bUsesWaterWalking() { return { this, "APrimalDinoCharacter.bUsesWaterWalking" }; }
    BitFieldValue<bool, unsigned __int32> bHasInvisiableSaddle() { return { this, "APrimalDinoCharacter.bHasInvisiableSaddle" }; }
    BitFieldValue<bool, unsigned __int32> bUseWildDinoMapMultipliers() { return { this, "APrimalDinoCharacter.bUseWildDinoMapMultipliers" }; }
    BitFieldValue<bool, unsigned __int32> bIgnoreFlierRidingRestrictions() { return { this, "APrimalDinoCharacter.bIgnoreFlierRidingRestrictions" }; }
    BitFieldValue<bool, unsigned __int32> bRotatingUpdatesDinoIK() { return { this, "APrimalDinoCharacter.bRotatingUpdatesDinoIK" }; }
    BitFieldValue<bool, unsigned __int32> bUseBP_OverrideRiderCameraCollisionSweep() { return { this, "APrimalDinoCharacter.bUseBP_OverrideRiderCameraCollisionSweep" }; }
    BitFieldValue<bool, unsigned __int32> bDrawHealthBar() { return { this, "APrimalDinoCharacter.bDrawHealthBar" }; }
    BitFieldValue<bool, unsigned __int32> bUseShoulderMountedLaunch() { return { this, "APrimalDinoCharacter.bUseShoulderMountedLaunch" }; }
    BitFieldValue<bool, unsigned __int32> bUsePreciseLaunching() { return { this, "APrimalDinoCharacter.bUsePreciseLaunching" }; }
    BitFieldValue<bool, unsigned __int32> bDidSetupTamed() { return { this, "APrimalDinoCharacter.bDidSetupTamed" }; }
    BitFieldValue<bool, unsigned __int32> bIncrementedNumDinos() { return { this, "APrimalDinoCharacter.bIncrementedNumDinos" }; }
    BitFieldValue<bool, unsigned __int32> bAllowInvalidTameVersion() { return { this, "APrimalDinoCharacter.bAllowInvalidTameVersion" }; }
    BitFieldValue<bool, unsigned __int32> bForceAllowPvECarry() { return { this, "APrimalDinoCharacter.bForceAllowPvECarry" }; }
    BitFieldValue<bool, unsigned __int32> bUnderwaterMating() { return { this, "APrimalDinoCharacter.bUnderwaterMating" }; }
    BitFieldValue<bool, unsigned __int32> bBabyPreventExitingWater() { return { this, "APrimalDinoCharacter.bBabyPreventExitingWater" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOnMountStateChanged() { return { this, "APrimalDinoCharacter.bUseBPOnMountStateChanged" }; }
    BitFieldValue<bool, unsigned __int32> bHandleUseButtonPressBP() { return { this, "APrimalDinoCharacter.bHandleUseButtonPressBP" }; }
    BitFieldValue<bool, unsigned __int32> bGlideWhenFalling() { return { this, "APrimalDinoCharacter.bGlideWhenFalling" }; }
    BitFieldValue<bool, unsigned __int32> bGlideWhenMounted() { return { this, "APrimalDinoCharacter.bGlideWhenMounted" }; }
    BitFieldValue<bool, unsigned __int32> bForceAllowBackwardsMovement() { return { this, "APrimalDinoCharacter.bForceAllowBackwardsMovement" }; }
    BitFieldValue<bool, unsigned __int32> bPreventBackwardsWalking() { return { this, "APrimalDinoCharacter.bPreventBackwardsWalking" }; }
    BitFieldValue<bool, unsigned __int32> bSupplyPlayerMountedCarryAnimation() { return { this, "APrimalDinoCharacter.bSupplyPlayerMountedCarryAnimation" }; }
    BitFieldValue<bool, unsigned __int32> bForceAllowMountedCarryRunning() { return { this, "APrimalDinoCharacter.bForceAllowMountedCarryRunning" }; }
    BitFieldValue<bool, unsigned __int32> bCanLatch() { return { this, "APrimalDinoCharacter.bCanLatch" }; }
    BitFieldValue<bool, unsigned __int32> bIsLatched() { return { this, "APrimalDinoCharacter.bIsLatched" }; }
    BitFieldValue<bool, unsigned __int32> bIsLatchedDownward() { return { this, "APrimalDinoCharacter.bIsLatchedDownward" }; }
    BitFieldValue<bool, unsigned __int32> bIsLatching() { return { this, "APrimalDinoCharacter.bIsLatching" }; }
    BitFieldValue<bool, unsigned __int32> bRotateToFaceLatchingObject() { return { this, "APrimalDinoCharacter.bRotateToFaceLatchingObject" }; }
    BitFieldValue<bool, unsigned __int32> bLimitRiderYawOnLatched() { return { this, "APrimalDinoCharacter.bLimitRiderYawOnLatched" }; }
    BitFieldValue<bool, unsigned __int32> bAllowMountedWeaponry() { return { this, "APrimalDinoCharacter.bAllowMountedWeaponry" }; }
    BitFieldValue<bool, unsigned __int32> bKeepAffinityOnDamageRecievedWakingTame() { return { this, "APrimalDinoCharacter.bKeepAffinityOnDamageRecievedWakingTame" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPFedWakingTameEvent() { return { this, "APrimalDinoCharacter.bUseBPFedWakingTameEvent" }; }
    BitFieldValue<bool, unsigned __int32> bForceRiderDrawCrosshair() { return { this, "APrimalDinoCharacter.bForceRiderDrawCrosshair" }; }
    BitFieldValue<bool, unsigned __int32> bForceDrawHUD() { return { this, "APrimalDinoCharacter.bForceDrawHUD" }; }
    BitFieldValue<bool, unsigned __int32> bForceDrawHUDWithoutRecentlyRendered() { return { this, "APrimalDinoCharacter.bForceDrawHUDWithoutRecentlyRendered" }; }
    BitFieldValue<bool, unsigned __int32> bHideFloatingName() { return { this, "APrimalDinoCharacter.bHideFloatingName" }; }
    BitFieldValue<bool, unsigned __int32> bCanTargetVehicles() { return { this, "APrimalDinoCharacter.bCanTargetVehicles" }; }
    BitFieldValue<bool, unsigned __int32> bRidingRequiresTamed() { return { this, "APrimalDinoCharacter.bRidingRequiresTamed" }; }
    BitFieldValue<bool, unsigned __int32> bSuppressDeathNotification() { return { this, "APrimalDinoCharacter.bSuppressDeathNotification" }; }
    BitFieldValue<bool, unsigned __int32> bUseCustomHealthBarColor() { return { this, "APrimalDinoCharacter.bUseCustomHealthBarColor" }; }
    BitFieldValue<bool, unsigned __int32> bUseOnUpdateMountedDinoMeshHiding() { return { this, "APrimalDinoCharacter.bUseOnUpdateMountedDinoMeshHiding" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPInterceptTurnInputEvents() { return { this, "APrimalDinoCharacter.bUseBPInterceptTurnInputEvents" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPInterceptMoveInputEvents() { return { this, "APrimalDinoCharacter.bUseBPInterceptMoveInputEvents" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPAdjustAttackIndex() { return { this, "APrimalDinoCharacter.bUseBPAdjustAttackIndex" }; }
    BitFieldValue<bool, unsigned __int32> bCheckBPAllowCarryCharacter() { return { this, "APrimalDinoCharacter.bCheckBPAllowCarryCharacter" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOnEndCharging() { return { this, "APrimalDinoCharacter.bUseBPOnEndCharging" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPNotifyMateBoostChanged() { return { this, "APrimalDinoCharacter.bUseBPNotifyMateBoostChanged" }; }
    BitFieldValue<bool, unsigned __int32> bForceAllowBackwardsMovementWithNoRider() { return { this, "APrimalDinoCharacter.bForceAllowBackwardsMovementWithNoRider" }; }
    BitFieldValue<bool, unsigned __int32> bIsCorrupted() { return { this, "APrimalDinoCharacter.bIsCorrupted" }; }
    BitFieldValue<bool, unsigned __int32> bIsHordeDino() { return { this, "APrimalDinoCharacter.bIsHordeDino" }; }
    BitFieldValue<bool, unsigned __int32> bBPOverrideHealthBarOffset() { return { this, "APrimalDinoCharacter.bBPOverrideHealthBarOffset" }; }
    BitFieldValue<bool, unsigned __int32> bDropWildEggsWithoutMateBoost() { return { this, "APrimalDinoCharacter.bDropWildEggsWithoutMateBoost" }; }
    BitFieldValue<bool, unsigned __int32> bIsTemporaryMissionDino() { return { this, "APrimalDinoCharacter.bIsTemporaryMissionDino" }; }
    BitFieldValue<bool, unsigned __int32> bForcePreventInventoryAccess() { return { this, "APrimalDinoCharacter.bForcePreventInventoryAccess" }; }
    BitFieldValue<bool, unsigned __int32> bAllowWildRunningWithoutTarget() { return { this, "APrimalDinoCharacter.bAllowWildRunningWithoutTarget" }; }
 
    // Functions
 
    static UClass * GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "APrimalDinoCharacter.GetPrivateStaticClass"); }
    static UClass * StaticClass() { return NativeCall<UClass*>(nullptr, "APrimalDinoCharacter.StaticClass"); }
    UObject * GetUObjectInterfaceDataListEntryInterface() { return NativeCall<UObject*>(this, "APrimalDinoCharacter.GetUObjectInterfaceDataListEntryInterface"); }
    void OnDinoStartled(UAnimMontage * StartledAnimPlayed, bool bFromAIController) { NativeCall<void, UAnimMontage*, bool>(this, "APrimalDinoCharacter.OnDinoStartled", StartledAnimPlayed, bFromAIController); }
    float GetXPMultiplier() { return NativeCall<float>(this, "APrimalDinoCharacter.GetXPMultiplier"); }
    bool IsBossDino() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsBossDino"); }
    bool UseHighQualityMovement() { return NativeCall<bool>(this, "APrimalDinoCharacter.UseHighQualityMovement"); }
    bool AllowPushOthers() { return NativeCall<bool>(this, "APrimalDinoCharacter.AllowPushOthers"); }
    FVector * GetActorCenterTraceLocation(FVector * result) { return NativeCall<FVector*, FVector*>(this, "APrimalDinoCharacter.GetActorCenterTraceLocation", result); }
    void CheckAndHandleBasedPlayersBeingPushedThroughWalls() { NativeCall<void>(this, "APrimalDinoCharacter.CheckAndHandleBasedPlayersBeingPushedThroughWalls"); }
    void Tick(float DeltaSeconds) { NativeCall<void, float>(this, "APrimalDinoCharacter.Tick", DeltaSeconds); }
    void PlayHardEndChargingShake_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.PlayHardEndChargingShake_Implementation"); }
    void SetForcedAggro(ITargetableInterface * Targetable, float AggroAmount, float ForcedAggroTime) { NativeCall<void, ITargetableInterface*, float, float>(this, "APrimalDinoCharacter.SetForcedAggro", Targetable, AggroAmount, ForcedAggroTime); }
    void BPSetForcedAggro(AActor * TargetableActor, float AggroAmount, float ForcedAggroTime) { NativeCall<void, AActor*, float, float>(this, "APrimalDinoCharacter.BPSetForcedAggro", TargetableActor, AggroAmount, ForcedAggroTime); }
    float GetAttackRangeOffset() { return NativeCall<float>(this, "APrimalDinoCharacter.GetAttackRangeOffset"); }
    void PlayDying(float KillingDamage, FDamageEvent * DamageEvent, APawn * InstigatingPawn, AActor * DamageCauser) { NativeCall<void, float, FDamageEvent*, APawn*, AActor*>(this, "APrimalDinoCharacter.PlayDying", KillingDamage, DamageEvent, InstigatingPawn, DamageCauser); }
    void AutoDrag() { NativeCall<void>(this, "APrimalDinoCharacter.AutoDrag"); }
    bool CanRide(AShooterCharacter * byPawn, char* bOutHasSaddle, char* bOutCanRideOtherThanSaddle, bool bDontCheckDistance) { return NativeCall<bool, AShooterCharacter*, char*, char*, bool>(this, "APrimalDinoCharacter.CanRide", byPawn, bOutHasSaddle, bOutCanRideOtherThanSaddle, bDontCheckDistance); }
    bool CanCryo(AShooterPlayerController * ForPC) { return NativeCall<bool, AShooterPlayerController*>(this, "APrimalDinoCharacter.CanCryo", ForPC); }
    void Stasis() { NativeCall<void>(this, "APrimalDinoCharacter.Stasis"); }
    void Unstasis() { NativeCall<void>(this, "APrimalDinoCharacter.Unstasis"); }
    void HandleUnstasised(bool bWasFromHibernation) { NativeCall<void, bool>(this, "APrimalDinoCharacter.HandleUnstasised", bWasFromHibernation); }
    bool IsRemoteDino() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsRemoteDino"); }
    bool IsValidUnStasisCaster() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsValidUnStasisCaster"); }
    void PostInitializeComponents() { NativeCall<void>(this, "APrimalDinoCharacter.PostInitializeComponents"); }
    void PostInitProperties() { NativeCall<void>(this, "APrimalDinoCharacter.PostInitProperties"); }
    void RegisterAllComponents() { NativeCall<void>(this, "APrimalDinoCharacter.RegisterAllComponents"); }
    int GetRandomBaseLevel() { return NativeCall<int>(this, "APrimalDinoCharacter.GetRandomBaseLevel"); }
    bool AllowZoneAutoKill() { return NativeCall<bool>(this, "APrimalDinoCharacter.AllowZoneAutoKill"); }
    void StopActiveState(bool bShouldResetAttackIndex) { NativeCall<void, bool>(this, "APrimalDinoCharacter.StopActiveState", bShouldResetAttackIndex); }
    bool DoAttack(int AttackIndex, bool bSetCurrentAttack, bool bInterruptCurrentAttack) { return NativeCall<bool, int, bool, bool>(this, "APrimalDinoCharacter.DoAttack", AttackIndex, bSetCurrentAttack, bInterruptCurrentAttack); }
    bool CancelCurrentAttack(bool bStopCurrentAttackAnim, float AttackAnimBlendOutTime) { return NativeCall<bool, bool, float>(this, "APrimalDinoCharacter.CancelCurrentAttack", bStopCurrentAttackAnim, AttackAnimBlendOutTime); }
    void ApplyRidingAttackExtraVelocity() { NativeCall<void>(this, "APrimalDinoCharacter.ApplyRidingAttackExtraVelocity"); }
    bool HasReachedDestination(FVector * Goal) { return NativeCall<bool, FVector*>(this, "APrimalDinoCharacter.HasReachedDestination", Goal); }
    bool IsDamageOccludedByStructures(AActor * DamageCauser) { return NativeCall<bool, AActor*>(this, "APrimalDinoCharacter.IsDamageOccludedByStructures", DamageCauser); }
    bool DisableHarvesting() { return NativeCall<bool>(this, "APrimalDinoCharacter.DisableHarvesting"); }
    float TakeDamage(float Damage, FDamageEvent * DamageEvent, AController * EventInstigator, AActor * DamageCauser) { return NativeCall<float, float, FDamageEvent*, AController*, AActor*>(this, "APrimalDinoCharacter.TakeDamage", Damage, DamageEvent, EventInstigator, DamageCauser); }
    bool CanAttack(int AttackIndex) { return NativeCall<bool, int>(this, "APrimalDinoCharacter.CanAttack", AttackIndex); }
    bool IsAttacking() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsAttacking"); }
    void PlayAttackAnimationOfAnimationArray(int AnimationIndex, TArray<UAnimMontage*> attackAnimations) { NativeCall<void, int, TArray<UAnimMontage*>>(this, "APrimalDinoCharacter.PlayAttackAnimationOfAnimationArray", AnimationIndex, attackAnimations); }
    void PlayWeightedAttackAnimation() { NativeCall<void>(this, "APrimalDinoCharacter.PlayWeightedAttackAnimation"); }
    bool IsCurrentlyPlayingAttackAnimation() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsCurrentlyPlayingAttackAnimation"); }
    bool IsWakingTame() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsWakingTame"); }
    void OnDinoCheat(FName CheatName, bool bSetValue, float Value) { NativeCall<void, FName, bool, float>(this, "APrimalDinoCharacter.OnDinoCheat", CheatName, bSetValue, Value); }
    bool AddToMeleeSwingHurtList(AActor * AnActor) { return NativeCall<bool, AActor*>(this, "APrimalDinoCharacter.AddToMeleeSwingHurtList", AnActor); }
    bool ShouldDealDamage(AActor * TestActor) { return NativeCall<bool, AActor*>(this, "APrimalDinoCharacter.ShouldDealDamage", TestActor); }
    void DealDamage(FHitResult * Impact, FVector * ShootDir, int DamageAmount, TSubclassOf<UDamageType> DamageType, float Impulse) { NativeCall<void, FHitResult*, FVector*, int, TSubclassOf<UDamageType>, float>(this, "APrimalDinoCharacter.DealDamage", Impact, ShootDir, DamageAmount, DamageType, Impulse); }
    bool CanCarryCharacter(APrimalCharacter * CanCarryPawn) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalDinoCharacter.CanCarryCharacter", CanCarryPawn); }
    bool AllowCarryCharacter(APrimalCharacter * CanCarryPawn) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalDinoCharacter.AllowCarryCharacter", CanCarryPawn); }
    bool CarryCharacter(APrimalCharacter * character, bool byPassCanCarryCheck) { return NativeCall<bool, APrimalCharacter*, bool>(this, "APrimalDinoCharacter.CarryCharacter", character, byPassCanCarryCheck); }
    void ClearCarriedCharacter(bool fromCarriedCharacter, bool bCancelAnyCarryBuffs) { NativeCall<void, bool, bool>(this, "APrimalDinoCharacter.ClearCarriedCharacter", fromCarriedCharacter, bCancelAnyCarryBuffs); }
    void OnRep_bIsCharging() { NativeCall<void>(this, "APrimalDinoCharacter.OnRep_bIsCharging"); }
    void ClearPassengers() { NativeCall<void>(this, "APrimalDinoCharacter.ClearPassengers"); }
    bool AddPassenger(APrimalCharacter * Character, int PassengerSeatIndex, bool bForcePassenger, bool bAllowFlyersAndWaterDinos, bool bSkipLineTrace) { return NativeCall<bool, APrimalCharacter*, int, bool, bool, bool>(this, "APrimalDinoCharacter.AddPassenger", Character, PassengerSeatIndex, bForcePassenger, bAllowFlyersAndWaterDinos, bSkipLineTrace); }
    void RemovePassenger(APrimalCharacter * Character, bool bFromCharacter, bool bFromPlayerController) { NativeCall<void, APrimalCharacter*, bool, bool>(this, "APrimalDinoCharacter.RemovePassenger", Character, bFromCharacter, bFromPlayerController); }
    bool CheckLocalPassengers() { return NativeCall<bool>(this, "APrimalDinoCharacter.CheckLocalPassengers"); }
    bool IsPassengerSeatAvailable(int PassengerSeatIndex) { return NativeCall<bool, int>(this, "APrimalDinoCharacter.IsPassengerSeatAvailable", PassengerSeatIndex); }
    int GetNumAvailablePassengerSeats(bool bOnlyManualPassengerSeats) { return NativeCall<int, bool>(this, "APrimalDinoCharacter.GetNumAvailablePassengerSeats", bOnlyManualPassengerSeats); }
    bool CanTakePassenger(APrimalCharacter * Character, int PassengerSeatIndex, bool bForcePassenger, bool bAllowFlyersAndWaterDinos, bool bSkipLineTrace) { return NativeCall<bool, APrimalCharacter*, int, bool, bool, bool>(this, "APrimalDinoCharacter.CanTakePassenger", Character, PassengerSeatIndex, bForcePassenger, bAllowFlyersAndWaterDinos, bSkipLineTrace); }
    int GetNumPassengerSeats(bool bOnlyManualPassengerSeats) { return NativeCall<int, bool>(this, "APrimalDinoCharacter.GetNumPassengerSeats", bOnlyManualPassengerSeats); }
    FSaddlePassengerSeatDefinition * GetPassengerSeatDefinition(char SeatIndex) { return NativeCall<FSaddlePassengerSeatDefinition*, char>(this, "APrimalDinoCharacter.GetPassengerSeatDefinition", SeatIndex); }
    void OnRep_PassengerPerSeat() { NativeCall<void>(this, "APrimalDinoCharacter.OnRep_PassengerPerSeat"); }
    void OnRep_bIsFlying() { NativeCall<void>(this, "APrimalDinoCharacter.OnRep_bIsFlying"); }
    void ServerToggleCharging_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerToggleCharging_Implementation"); }
    void StartCharging(bool bForce) { NativeCall<void, bool>(this, "APrimalDinoCharacter.StartCharging", bForce); }
    void PlayChargingAnim() { NativeCall<void>(this, "APrimalDinoCharacter.PlayChargingAnim"); }
    void EndCharging(bool bForce) { NativeCall<void, bool>(this, "APrimalDinoCharacter.EndCharging", bForce); }
    bool AllowHurtAnimation() { return NativeCall<bool>(this, "APrimalDinoCharacter.AllowHurtAnimation"); }
    void SetRider(AShooterCharacter * aRider) { NativeCall<void, AShooterCharacter*>(this, "APrimalDinoCharacter.SetRider", aRider); }
    void OnRep_Rider() { NativeCall<void>(this, "APrimalDinoCharacter.OnRep_Rider"); }
    void OnRep_CarriedCharacter() { NativeCall<void>(this, "APrimalDinoCharacter.OnRep_CarriedCharacter"); }
    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty> * OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "APrimalDinoCharacter.GetLifetimeReplicatedProps", OutLifetimeProps); }
    void ForceUpdateColorSets_Implementation(int ColorRegion, int ColorSet) { NativeCall<void, int, int>(this, "APrimalDinoCharacter.ForceUpdateColorSets_Implementation", ColorRegion, ColorSet); }
    void MulticastUpdateAllColorSets_Implementation(int Color0, int Color1, int Color2, int Color3, int Color4, int Color5) { NativeCall<void, int, int, int, int, int, int>(this, "APrimalDinoCharacter.MulticastUpdateAllColorSets_Implementation", Color0, Color1, Color2, Color3, Color4, Color5); }
    FString * GetDescriptiveName(FString * result) { return NativeCall<FString*, FString*>(this, "APrimalDinoCharacter.GetDescriptiveName", result); }
    FString * GetShortName(FString * result) { return NativeCall<FString*, FString*>(this, "APrimalDinoCharacter.GetShortName", result); }
    FString * GetCurrentDinoName(FString * result, APlayerController * ForPC) { return NativeCall<FString*, FString*, APlayerController*>(this, "APrimalDinoCharacter.GetCurrentDinoName", result, ForPC); }
    void ForceClearRider() { NativeCall<void>(this, "APrimalDinoCharacter.ForceClearRider"); }
    bool CanClearRider() { return NativeCall<bool>(this, "APrimalDinoCharacter.CanClearRider"); }
    void ClearRider(bool FromRider, bool bCancelForceLand, bool SpawnDinoDefaultController, int OverrideUnboardDirection, bool bForceEvenIfBuffPreventsClear) { NativeCall<void, bool, bool, bool, int, bool>(this, "APrimalDinoCharacter.ClearRider", FromRider, bCancelForceLand, SpawnDinoDefaultController, OverrideUnboardDirection, bForceEvenIfBuffPreventsClear); }
    void ControllerLeavingGame(AShooterPlayerController * theController) { NativeCall<void, AShooterPlayerController*>(this, "APrimalDinoCharacter.ControllerLeavingGame", theController); }
    FString * GetEntryString(FString * result) { return NativeCall<FString*, FString*>(this, "APrimalDinoCharacter.GetEntryString", result); }
    UTexture2D * GetEntryIcon(UObject * AssociatedDataObject, bool bIsEnabled) { return NativeCall<UTexture2D*, UObject*, bool>(this, "APrimalDinoCharacter.GetEntryIcon", AssociatedDataObject, bIsEnabled); }
    UMaterialInterface * GetEntryIconMaterial(UObject * AssociatedDataObject, bool bIsEnabled) { return NativeCall<UMaterialInterface*, UObject*, bool>(this, "APrimalDinoCharacter.GetEntryIconMaterial", AssociatedDataObject, bIsEnabled); }
    UObject * GetObjectW() { return NativeCall<UObject*>(this, "APrimalDinoCharacter.GetObjectW"); }
    FString * GetEntryDescription(FString * result) { return NativeCall<FString*, FString*>(this, "APrimalDinoCharacter.GetEntryDescription", result); }
    UTexture * GetDinoEntryIcon() { return NativeCall<UTexture*>(this, "APrimalDinoCharacter.GetDinoEntryIcon"); }
    void DrawHUD(AShooterHUD * HUD) { NativeCall<void, AShooterHUD*>(this, "APrimalDinoCharacter.DrawHUD", HUD); }
    bool CanOrder(APrimalCharacter * FromCharacter, bool bBuildingStructures) { return NativeCall<bool, APrimalCharacter*, bool>(this, "APrimalDinoCharacter.CanOrder", FromCharacter, bBuildingStructures); }
    bool TamedProcessOrder(APrimalCharacter * FromCharacter, EDinoTamedOrder::Type OrderType, bool bForce, AActor * enemyTarget) { return NativeCall<bool, APrimalCharacter*, EDinoTamedOrder::Type, bool, AActor*>(this, "APrimalDinoCharacter.TamedProcessOrder", FromCharacter, OrderType, bForce, enemyTarget); }
    void ServerSleepingTick() { NativeCall<void>(this, "APrimalDinoCharacter.ServerSleepingTick"); }
    float GetAffinityIncreaseForFoodItem(UPrimalItem * foodItem) { return NativeCall<float, UPrimalItem*>(this, "APrimalDinoCharacter.GetAffinityIncreaseForFoodItem", foodItem); }
    void ServerTamedTick() { NativeCall<void>(this, "APrimalDinoCharacter.ServerTamedTick"); }
    UPrimalItem * GetBestInventoryFoodItem(float* FoodIncrease, bool bLookForAffinity, bool bFoodItemRequiresLivePlayerCharacter, UPrimalItem * *foundFoodItem, bool bLookForWorstFood) { return NativeCall<UPrimalItem*, float*, bool, bool, UPrimalItem**, bool>(this, "APrimalDinoCharacter.GetBestInventoryFoodItem", FoodIncrease, bLookForAffinity, bFoodItemRequiresLivePlayerCharacter, foundFoodItem, bLookForWorstFood); }
    AShooterCharacter * ConsumeInventoryFoodItem(UPrimalItem * foodItem, float* AffinityIncrease, bool bDontDecrementItem, float* FoodIncrease, float FoodAmountMultiplier, bool bConsumeEntireStack) { return NativeCall<AShooterCharacter*, UPrimalItem*, float*, bool, float*, float, bool>(this, "APrimalDinoCharacter.ConsumeInventoryFoodItem", foodItem, AffinityIncrease, bDontDecrementItem, FoodIncrease, FoodAmountMultiplier, bConsumeEntireStack); }
    AShooterCharacter * FindFirstFoodItemPlayerCharacter() { return NativeCall<AShooterCharacter*>(this, "APrimalDinoCharacter.FindFirstFoodItemPlayerCharacter"); }
    int GetFoodItemEffectivenessMultipliersIndex(UPrimalItem * foodItem) { return NativeCall<int, UPrimalItem*>(this, "APrimalDinoCharacter.GetFoodItemEffectivenessMultipliersIndex", foodItem); }
    TSubclassOf<UPrimalItem> * GetFirstAffinityFoodItemClass(TSubclassOf<UPrimalItem> * result) { return NativeCall<TSubclassOf<UPrimalItem>*, TSubclassOf<UPrimalItem>*>(this, "APrimalDinoCharacter.GetFirstAffinityFoodItemClass", result); }
    int GetExtraFoodItemEffectivenessMultipliersIndex(UPrimalItem * foodItem) { return NativeCall<int, UPrimalItem*>(this, "APrimalDinoCharacter.GetExtraFoodItemEffectivenessMultipliersIndex", foodItem); }
    void ServerClearRider_Implementation(int OverrideUnboardDirection) { NativeCall<void, int>(this, "APrimalDinoCharacter.ServerClearRider_Implementation", OverrideUnboardDirection); }
    void ElevateDinoBP(float Val) { NativeCall<void, float>(this, "APrimalDinoCharacter.ElevateDinoBP", Val); }
    void OnElevateDino(float Val) { NativeCall<void, float>(this, "APrimalDinoCharacter.OnElevateDino", Val); }
    void LowerDinoBP(float Val) { NativeCall<void, float>(this, "APrimalDinoCharacter.LowerDinoBP", Val); }
    void OnLowerDino(float Val) { NativeCall<void, float>(this, "APrimalDinoCharacter.OnLowerDino", Val); }
    void BrakeDinoBP(float Val) { NativeCall<void, float>(this, "APrimalDinoCharacter.BrakeDinoBP", Val); }
    void OnBrake() { NativeCall<void>(this, "APrimalDinoCharacter.OnBrake"); }
    void OffBrake() { NativeCall<void>(this, "APrimalDinoCharacter.OffBrake"); }
    void ServerRequestBraking_Implementation(bool bWantsToBrake) { NativeCall<void, bool>(this, "APrimalDinoCharacter.ServerRequestBraking_Implementation", bWantsToBrake); }
    void OnStartFire(bool bFromGamepadRight) { NativeCall<void, bool>(this, "APrimalDinoCharacter.OnStartFire", bFromGamepadRight); }
    void OnStopFire(bool bFromGamepadRight) { NativeCall<void, bool>(this, "APrimalDinoCharacter.OnStopFire", bFromGamepadRight); }
    void OnStartTargeting(bool bFromGamepadLeft) { NativeCall<void, bool>(this, "APrimalDinoCharacter.OnStartTargeting", bFromGamepadLeft); }
    void OnControllerInitiatedAttack(int AttackIndex) { NativeCall<void, int>(this, "APrimalDinoCharacter.OnControllerInitiatedAttack", AttackIndex); }
    void UpdateAttackTargets() { NativeCall<void>(this, "APrimalDinoCharacter.UpdateAttackTargets"); }
    bool IsMovementTethered() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsMovementTethered"); }
    FVector * GetTargetPathfindingLocation(FVector * result, AActor * Attacker) { return NativeCall<FVector*, FVector*, AActor*>(this, "APrimalDinoCharacter.GetTargetPathfindingLocation", result, Attacker); }
    float GetApproachRadius() { return NativeCall<float>(this, "APrimalDinoCharacter.GetApproachRadius"); }
    FVector * GetTargetingLocation(FVector * result, AActor * Attacker) { return NativeCall<FVector*, FVector*, AActor*>(this, "APrimalDinoCharacter.GetTargetingLocation", result, Attacker); }
    bool GetClosestTargetOverride(FVector * attackPos, FVector * targetPos) { return NativeCall<bool, FVector*, FVector*>(this, "APrimalDinoCharacter.GetClosestTargetOverride", attackPos, targetPos); }
    void ExportDino(APlayerController * ForPC) { NativeCall<void, APlayerController*>(this, "APrimalDinoCharacter.ExportDino", ForPC); }
    void ServerUpdateAttackTargets_Implementation(AActor * AttackTarget, FVector AttackLocation) { NativeCall<void, AActor*, FVector>(this, "APrimalDinoCharacter.ServerUpdateAttackTargets_Implementation", AttackTarget, AttackLocation); }
    void GetAttackTargets(AActor * *attackActor, FVector * attackLoc) { NativeCall<void, AActor**, FVector*>(this, "APrimalDinoCharacter.GetAttackTargets", attackActor, attackLoc); }
    void ServerRequestAttack_Implementation(int attackIndex) { NativeCall<void, int>(this, "APrimalDinoCharacter.ServerRequestAttack_Implementation", attackIndex); }
    void OnPrimalCharacterSleeped() { NativeCall<void>(this, "APrimalDinoCharacter.OnPrimalCharacterSleeped"); }
    void UnPossessed() { NativeCall<void>(this, "APrimalDinoCharacter.UnPossessed"); }
    FRotator * ProcessRootRotAndLoc(FRotator * result, float DeltaTime, FVector * RootLocOffset, FRotator * RootRotOffset, float* RootYawSpeed, float MaxYawAimClamp, float CurrentAimBlending, FRotator * TargetAimRot, float* RootRot) { return NativeCall<FRotator*, FRotator*, float, FVector*, FRotator*, float*, float, float, FRotator*, float*>(this, "APrimalDinoCharacter.ProcessRootRotAndLoc", result, DeltaTime, RootLocOffset, RootRotOffset, RootYawSpeed, MaxYawAimClamp, CurrentAimBlending, TargetAimRot, RootRot); }
    FRotator * GetAimOffsets(FRotator * result, float DeltaTime, FRotator * RootRotOffset, float* RootYawSpeed, float MaxYawAimClamp, FVector * RootLocOffset) { return NativeCall<FRotator*, FRotator*, float, FRotator*, float*, float, FVector*>(this, "APrimalDinoCharacter.GetAimOffsets", result, DeltaTime, RootRotOffset, RootYawSpeed, MaxYawAimClamp, RootLocOffset); }
    FRotator * GetAimOffsetsTransform(FRotator * result, float DeltaTime, FTransform * RootRotOffsetTransform, float* RootYawSpeed, float MaxYawAimClamp, FVector * RootLocOffset) { return NativeCall<FRotator*, FRotator*, float, FTransform*, float*, float, FVector*>(this, "APrimalDinoCharacter.GetAimOffsetsTransform", result, DeltaTime, RootRotOffsetTransform, RootYawSpeed, MaxYawAimClamp, RootLocOffset); }
    FRotator * GetCurrentAimOffsetsRotation(FRotator * result) { return NativeCall<FRotator*, FRotator*>(this, "APrimalDinoCharacter.GetCurrentAimOffsetsRotation", result); }
    float GetRootYawSpeed(float DeltaTime) { return NativeCall<float, float>(this, "APrimalDinoCharacter.GetRootYawSpeed", DeltaTime); }
    void TempDampenInputAcceleration() { NativeCall<void>(this, "APrimalDinoCharacter.TempDampenInputAcceleration"); }
    bool ModifyInputAcceleration(FVector * InputAcceleration) { return NativeCall<bool, FVector*>(this, "APrimalDinoCharacter.ModifyInputAcceleration", InputAcceleration); }
    float GetMaxSpeedModifier() { return NativeCall<float>(this, "APrimalDinoCharacter.GetMaxSpeedModifier"); }
    bool IsInTekShield() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsInTekShield"); }
    float GetSpeedModifier() { return NativeCall<float>(this, "APrimalDinoCharacter.GetSpeedModifier"); }
    TArray<AActor*> * GetDinoPlatformCollisionIgnoreActors(TArray<AActor*> * result) { return NativeCall<TArray<AActor*>*, TArray<AActor*>*>(this, "APrimalDinoCharacter.GetDinoPlatformCollisionIgnoreActors", result); }
    float GetRotationRateModifier() { return NativeCall<float>(this, "APrimalDinoCharacter.GetRotationRateModifier"); }
    bool IsFleeing() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsFleeing"); }
    void FaceRotation(FRotator NewControlRotation, float DeltaTime, bool bFromController) { NativeCall<void, FRotator, float, bool>(this, "APrimalDinoCharacter.FaceRotation", NewControlRotation, DeltaTime, bFromController); }
    void MoveForward(float Val) { NativeCall<void, float>(this, "APrimalDinoCharacter.MoveForward", Val); }
    void MoveRight(float Val) { NativeCall<void, float>(this, "APrimalDinoCharacter.MoveRight", Val); }
    void MoveUp(float Val) { NativeCall<void, float>(this, "APrimalDinoCharacter.MoveUp", Val); }
    void TurnInput(float Val) { NativeCall<void, float>(this, "APrimalDinoCharacter.TurnInput", Val); }
    void SetCurrentAttackIndex(char index) { NativeCall<void, char>(this, "APrimalDinoCharacter.SetCurrentAttackIndex", index); }
    void ResetCurrentAttackIndex() { NativeCall<void>(this, "APrimalDinoCharacter.ResetCurrentAttackIndex"); }
    int BPGetCurrentAttackIndex() { return NativeCall<int>(this, "APrimalDinoCharacter.BPGetCurrentAttackIndex"); }
    bool GetCurrentAttackInfo(int* AttackIndex, FDinoAttackInfo * AttackInfo) { return NativeCall<bool, int*, FDinoAttackInfo*>(this, "APrimalDinoCharacter.GetCurrentAttackInfo", AttackIndex, AttackInfo); }
    bool BPHasCurrentAttack() { return NativeCall<bool>(this, "APrimalDinoCharacter.BPHasCurrentAttack"); }
    char GetWiegthedAttack(float distance, float attackRangeOffset, AActor * OtherTarget) { return NativeCall<char, float, float, AActor*>(this, "APrimalDinoCharacter.GetWiegthedAttack", distance, attackRangeOffset, OtherTarget); }
    void FireProjectileLocal(FVector Origin, FVector_NetQuantizeNormal ShootDir, bool bScaleProjDamageByDinoDamage) { NativeCall<void, FVector, FVector_NetQuantizeNormal, bool>(this, "APrimalDinoCharacter.FireProjectileLocal", Origin, ShootDir, bScaleProjDamageByDinoDamage); }
    void DinoFireProjectileEx_Implementation(TSubclassOf<AShooterProjectile> ProjectileClass, FVector Origin, FVector_NetQuantizeNormal ShootDir, bool bScaleProjDamageByDinoDamage, bool bAddDinoVelocityToProjectile, float OverrideInitialSpeed, float OverrideMaxSpeed, float ExtraDirectDamageMultiplier, float ExtraExplosionDamageMultiplier, bool spawnOnOwningClient) { NativeCall<void, TSubclassOf<AShooterProjectile>, FVector, FVector_NetQuantizeNormal, bool, bool, float, float, float, float, bool>(this, "APrimalDinoCharacter.DinoFireProjectileEx_Implementation", ProjectileClass, Origin, ShootDir, bScaleProjDamageByDinoDamage, bAddDinoVelocityToProjectile, OverrideInitialSpeed, OverrideMaxSpeed, ExtraDirectDamageMultiplier, ExtraExplosionDamageMultiplier, spawnOnOwningClient); }
    void FireMultipleProjectilesEx_Implementation(TSubclassOf<AShooterProjectile> ProjectileClass, TArray<FVector> * Locations, TArray<FVector> * Directions, bool bAddPawnVelocityToProjectile, bool bScaleProjDamageByDinoDamage, USceneComponent * HomingTarget, FVector HomingTargetOffset, float OverrideInitialSpeed) { NativeCall<void, TSubclassOf<AShooterProjectile>, TArray<FVector>*, TArray<FVector>*, bool, bool, USceneComponent*, FVector, float>(this, "APrimalDinoCharacter.FireMultipleProjectilesEx_Implementation", ProjectileClass, Locations, Directions, bAddPawnVelocityToProjectile, bScaleProjDamageByDinoDamage, HomingTarget, HomingTargetOffset, OverrideInitialSpeed); }
    void FireProjectile_Implementation(FVector Origin, FVector_NetQuantizeNormal ShootDir, bool bScaleProjDamageByDinoDamage) { NativeCall<void, FVector, FVector_NetQuantizeNormal, bool>(this, "APrimalDinoCharacter.FireProjectile_Implementation", Origin, ShootDir, bScaleProjDamageByDinoDamage); }
    void ServerToClientsPlayAttackAnimation_Implementation(char AttackinfoIndex, char AnimationIndex, float InPlayRate, FName StartSectionName, bool bForceTickPoseAndServerUpdateMesh, bool bForceTickPoseOnServer, AActor * MyTarget) { NativeCall<void, char, char, float, FName, bool, bool, AActor*>(this, "APrimalDinoCharacter.ServerToClientsPlayAttackAnimation_Implementation", AttackinfoIndex, AnimationIndex, InPlayRate, StartSectionName, bForceTickPoseAndServerUpdateMesh, bForceTickPoseOnServer, MyTarget); }
    bool IsCurrentAttackStopsMovement() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsCurrentAttackStopsMovement"); }
    void ServerRequestToggleFlight_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerRequestToggleFlight_Implementation"); }
    void CalcCapsuleHalfHeight() { NativeCall<void>(this, "APrimalDinoCharacter.CalcCapsuleHalfHeight"); }
    void ClientStartLanding_Implementation(FVector loc) { NativeCall<void, FVector>(this, "APrimalDinoCharacter.ClientStartLanding_Implementation", loc); }
    void StartLanding(FVector OverrideLandingLocation) { NativeCall<void, FVector>(this, "APrimalDinoCharacter.StartLanding", OverrideLandingLocation); }
    bool IsLandingOnDino(FVector * loc) { return NativeCall<bool, FVector*>(this, "APrimalDinoCharacter.IsLandingOnDino", loc); }
    void ServerInterruptLanding_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerInterruptLanding_Implementation"); }
    void InterruptLanding() { NativeCall<void>(this, "APrimalDinoCharacter.InterruptLanding"); }
    void ClientInterruptLanding_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ClientInterruptLanding_Implementation"); }
    void ServerFinishedLanding_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerFinishedLanding_Implementation"); }
    void FinishedLanding() { NativeCall<void>(this, "APrimalDinoCharacter.FinishedLanding"); }
    void ClientShouldNotifyLanded_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ClientShouldNotifyLanded_Implementation"); }
    FVector * GetLandingLocation(FVector * result) { return NativeCall<FVector*, FVector*>(this, "APrimalDinoCharacter.GetLandingLocation", result); }
    bool CanFly() { return NativeCall<bool>(this, "APrimalDinoCharacter.CanFly"); }
    bool HasBuffPreventingFlight() { return NativeCall<bool>(this, "APrimalDinoCharacter.HasBuffPreventingFlight"); }
    bool HasBuffPreventingClearRiderOnDinoImmobilized() { return NativeCall<bool>(this, "APrimalDinoCharacter.HasBuffPreventingClearRiderOnDinoImmobilized"); }
    void SetFlight(bool bFly, bool bCancelForceLand) { NativeCall<void, bool, bool>(this, "APrimalDinoCharacter.SetFlight", bFly, bCancelForceLand); }
    void KeepFlight(float ForDuration) { NativeCall<void, float>(this, "APrimalDinoCharacter.KeepFlight", ForDuration); }
    void KeepFlightTimer() { NativeCall<void>(this, "APrimalDinoCharacter.KeepFlightTimer"); }
    void DidLand() { NativeCall<void>(this, "APrimalDinoCharacter.DidLand"); }
    void AddFlyerTakeOffImpulse() { NativeCall<void>(this, "APrimalDinoCharacter.AddFlyerTakeOffImpulse"); }
    void OnStartJump() { NativeCall<void>(this, "APrimalDinoCharacter.OnStartJump"); }
    void OnStopJump() { NativeCall<void>(this, "APrimalDinoCharacter.OnStopJump"); }
    void ServerRequestWaterSurfaceJump_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerRequestWaterSurfaceJump_Implementation"); }
    bool IsUpdatingComponentTransforms(USceneComponent * InSceneComponent) { return NativeCall<bool, USceneComponent*>(this, "APrimalDinoCharacter.IsUpdatingComponentTransforms", InSceneComponent); }
    bool UseLowQualityMovementTick() { return NativeCall<bool>(this, "APrimalDinoCharacter.UseLowQualityMovementTick"); }
    bool UseLowQualityAnimationTick() { return NativeCall<bool>(this, "APrimalDinoCharacter.UseLowQualityAnimationTick"); }
    bool UseLowQualityBehaviorTreeTick() { return NativeCall<bool>(this, "APrimalDinoCharacter.UseLowQualityBehaviorTreeTick"); }
    void UpdateNetDynamicMusic() { NativeCall<void>(this, "APrimalDinoCharacter.UpdateNetDynamicMusic"); }
    bool CanTame(AShooterPlayerController * ForPC, bool bIgnoreMaxTamedDinos) { return NativeCall<bool, AShooterPlayerController*, bool>(this, "APrimalDinoCharacter.CanTame", ForPC, bIgnoreMaxTamedDinos); }
    void SetupTamed(bool bWasJustTamed) { NativeCall<void, bool>(this, "APrimalDinoCharacter.SetupTamed", bWasJustTamed); }
    void TameDino(AShooterPlayerController * ForPC, bool bIgnoreMaxTameLimit, int OverrideTamingTeamID, bool bPreventNameDialog, bool bSkipAddingTamedLevels, bool bSuppressNotifications) { NativeCall<void, AShooterPlayerController*, bool, int, bool, bool, bool>(this, "APrimalDinoCharacter.TameDino", ForPC, bIgnoreMaxTameLimit, OverrideTamingTeamID, bPreventNameDialog, bSkipAddingTamedLevels, bSuppressNotifications); }
    void SetCharacterStatusTameable(bool bSetTameable, bool bCreateInventory, bool keepInventoryForWakingTame) { NativeCall<void, bool, bool, bool>(this, "APrimalDinoCharacter.SetCharacterStatusTameable", bSetTameable, bCreateInventory, keepInventoryForWakingTame); }
    void OnPrimalCharacterUnsleeped() { NativeCall<void>(this, "APrimalDinoCharacter.OnPrimalCharacterUnsleeped"); }
    bool IsValidForStatusUpdate() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsValidForStatusUpdate"); }
    AActor * GetOtherActorToIgnore() { return NativeCall<AActor*>(this, "APrimalDinoCharacter.GetOtherActorToIgnore"); }
    long double GetForceClaimTime() { return NativeCall<long double>(this, "APrimalDinoCharacter.GetForceClaimTime"); }
    void UnclaimDino(bool bDestroyAI) { NativeCall<void, bool>(this, "APrimalDinoCharacter.UnclaimDino", bDestroyAI); }
    bool TryMultiUse(APlayerController * ForPC, int UseIndex) { return NativeCall<bool, APlayerController*, int>(this, "APrimalDinoCharacter.TryMultiUse", ForPC, UseIndex); }
    bool SetTurretMode_Implementation(bool enabled) { return NativeCall<bool, bool>(this, "APrimalDinoCharacter.SetTurretMode_Implementation", enabled); }
    void SetTurretModeMovementRestrictions(bool enabled) { NativeCall<void, bool>(this, "APrimalDinoCharacter.SetTurretModeMovementRestrictions", enabled); }
    void ClientMultiUse(APlayerController * ForPC, int UseIndex) { NativeCall<void, APlayerController*, int>(this, "APrimalDinoCharacter.ClientMultiUse", ForPC, UseIndex); }
    void ChangeActorTeam(int NewTeam) { NativeCall<void, int>(this, "APrimalDinoCharacter.ChangeActorTeam", NewTeam); }
    void LinkedSupplyCrateDestroyed(APrimalStructureItemContainer_SupplyCrate * aCrate) { NativeCall<void, APrimalStructureItemContainer_SupplyCrate*>(this, "APrimalDinoCharacter.LinkedSupplyCrateDestroyed", aCrate); }
    bool AllowNewEggAtLocation(FVector * AtLocation) { return NativeCall<bool, FVector*>(this, "APrimalDinoCharacter.AllowNewEggAtLocation", AtLocation); }
    void SpawnEgg() { NativeCall<void>(this, "APrimalDinoCharacter.SpawnEgg"); }
    float GetRunningSpeedModifier(bool bIsForDefaultSpeed) { return NativeCall<float, bool>(this, "APrimalDinoCharacter.GetRunningSpeedModifier", bIsForDefaultSpeed); }
    void BeginPlay() { NativeCall<void>(this, "APrimalDinoCharacter.BeginPlay"); }
    void ForceRefreshTransform() { NativeCall<void>(this, "APrimalDinoCharacter.ForceRefreshTransform"); }
    void FlyerCheck() { NativeCall<void>(this, "APrimalDinoCharacter.FlyerCheck"); }
    void AutoTame() { NativeCall<void>(this, "APrimalDinoCharacter.AutoTame"); }
    void SetupColorization() { NativeCall<void>(this, "APrimalDinoCharacter.SetupColorization"); }
    void AssertColorNames() { NativeCall<void>(this, "APrimalDinoCharacter.AssertColorNames"); }
    void ReassertColorization() { NativeCall<void>(this, "APrimalDinoCharacter.ReassertColorization"); }
    TArray<unsigned char> * GetColorizationData(TArray<unsigned char> * result) { return NativeCall<TArray<unsigned char>*, TArray<unsigned char>*>(this, "APrimalDinoCharacter.GetColorizationData", result); }
    void SetColorizationData(TArray<unsigned char> * ColorData) { NativeCall<void, TArray<unsigned char>*>(this, "APrimalDinoCharacter.SetColorizationData", ColorData); }
    void ModifyFirstPersonCameraLocation(FVector * Loc, float DeltaTime) { NativeCall<void, FVector*, float>(this, "APrimalDinoCharacter.ModifyFirstPersonCameraLocation", Loc, DeltaTime); }
    void ServerRequestUseItemWithActor(APlayerController * ForPC, UObject * anItem, int AdditionalData) { NativeCall<void, APlayerController*, UObject*, int>(this, "APrimalDinoCharacter.ServerRequestUseItemWithActor", ForPC, anItem, AdditionalData); }
    void RefreshColorization(bool bForceRefresh) { NativeCall<void, bool>(this, "APrimalDinoCharacter.RefreshColorization", bForceRefresh); }
    bool CanTarget(ITargetableInterface * Victim) { return NativeCall<bool, ITargetableInterface*>(this, "APrimalDinoCharacter.CanTarget", Victim); }
    int GetOriginalTargetingTeam() { return NativeCall<int>(this, "APrimalDinoCharacter.GetOriginalTargetingTeam"); }
    float GetTargetingDesirability(ITargetableInterface * Attacker) { return NativeCall<float, ITargetableInterface*>(this, "APrimalDinoCharacter.GetTargetingDesirability", Attacker); }
    bool ShouldReplicateRotPitch() { return NativeCall<bool>(this, "APrimalDinoCharacter.ShouldReplicateRotPitch"); }
    void NetUpdateDinoNameStrings_Implementation(FString * NewTamerString, FString * NewTamedName) { NativeCall<void, FString*, FString*>(this, "APrimalDinoCharacter.NetUpdateDinoNameStrings_Implementation", NewTamerString, NewTamedName); }
    void ProcessEditText(AShooterPlayerController * ForPC, FString * TextToUse, bool checkedBox) { NativeCall<void, AShooterPlayerController*, FString*, bool>(this, "APrimalDinoCharacter.ProcessEditText", ForPC, TextToUse, checkedBox); }
    static APrimalDinoCharacter * FindDinoWithID(UWorld * aWorld, unsigned int DinoID1, unsigned int DinoID2) { return NativeCall<APrimalDinoCharacter*, UWorld*, unsigned int, unsigned int>(nullptr, "APrimalDinoCharacter.FindDinoWithID", aWorld, DinoID1, DinoID2); }
    void TargetingTeamChanged() { NativeCall<void>(this, "APrimalDinoCharacter.TargetingTeamChanged"); }
    void Destroyed() { NativeCall<void>(this, "APrimalDinoCharacter.Destroyed"); }
    void DrawFloatingHUD(AShooterHUD * HUD) { NativeCall<void, AShooterHUD*>(this, "APrimalDinoCharacter.DrawFloatingHUD", HUD); }
    void DrawDinoFloatingHUD(AShooterHUD * HUD, bool bDrawDinoOrderIcon) { NativeCall<void, AShooterHUD*, bool>(this, "APrimalDinoCharacter.DrawDinoFloatingHUD", HUD, bDrawDinoOrderIcon); }
    bool IsNearFeed(AShooterPlayerState * ForPlayer) { return NativeCall<bool, AShooterPlayerState*>(this, "APrimalDinoCharacter.IsNearFeed", ForPlayer); }
    void DeathHarvestingFadeOut_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.DeathHarvestingFadeOut_Implementation"); }
    void NotifyItemAdded(UPrimalItem * anItem, bool bEquipItem) { NativeCall<void, UPrimalItem*, bool>(this, "APrimalDinoCharacter.NotifyItemAdded", anItem, bEquipItem); }
    FString * GetDinoDescriptiveName(FString * result) { return NativeCall<FString*, FString*>(this, "APrimalDinoCharacter.GetDinoDescriptiveName", result); }
    TArray<FString> * GetDetailedDescription(TArray<FString> * result, FString * IndentPrefix) { return NativeCall<TArray<FString>*, TArray<FString>*, FString*>(this, "APrimalDinoCharacter.GetDetailedDescription", result, IndentPrefix); }
    void ServerGiveDefaultWeapon_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerGiveDefaultWeapon_Implementation"); }
    void ServerCallFollow_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerCallFollow_Implementation"); }
    void ServerCallFollowOne_Implementation(APrimalDinoCharacter * ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "APrimalDinoCharacter.ServerCallFollowOne_Implementation", ForDinoChar); }
    void ServerCallStay_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerCallStay_Implementation"); }
    void ServerCallStayOne_Implementation(APrimalDinoCharacter * ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "APrimalDinoCharacter.ServerCallStayOne_Implementation", ForDinoChar); }
    void ServerCallFollowDistanceCycleOne_Implementation(APrimalDinoCharacter * ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "APrimalDinoCharacter.ServerCallFollowDistanceCycleOne_Implementation", ForDinoChar); }
    void ServerCallLandFlyerOne_Implementation(APrimalDinoCharacter * ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "APrimalDinoCharacter.ServerCallLandFlyerOne_Implementation", ForDinoChar); }
    void ServerCallAggressive_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerCallAggressive_Implementation"); }
    void ServerCallSetAggressive_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerCallSetAggressive_Implementation"); }
    void ServerCallNeutral_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerCallNeutral_Implementation"); }
    void ServerCallPassive_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerCallPassive_Implementation"); }
    void ServerCallAttackTarget_Implementation(AActor * TheTarget) { NativeCall<void, AActor*>(this, "APrimalDinoCharacter.ServerCallAttackTarget_Implementation", TheTarget); }
    void ServerCallMoveTo_Implementation(FVector MoveToLoc) { NativeCall<void, FVector>(this, "APrimalDinoCharacter.ServerCallMoveTo_Implementation", MoveToLoc); }
    void NotifyItemRemoved(UPrimalItem * anItem) { NativeCall<void, UPrimalItem*>(this, "APrimalDinoCharacter.NotifyItemRemoved", anItem); }
    float GetCorpseLifespan() { return NativeCall<float>(this, "APrimalDinoCharacter.GetCorpseLifespan"); }
    void UpdateMateBoost() { NativeCall<void>(this, "APrimalDinoCharacter.UpdateMateBoost"); }
    void AdjustDamage(float* Damage, FDamageEvent * DamageEvent, AController * EventInstigator, AActor * DamageCauser) { NativeCall<void, float*, FDamageEvent*, AController*, AActor*>(this, "APrimalDinoCharacter.AdjustDamage", Damage, DamageEvent, EventInstigator, DamageCauser); }
    void SpawnDefaultController() { NativeCall<void>(this, "APrimalDinoCharacter.SpawnDefaultController"); }
    bool AllowFallDamage(FHitResult * HitResult, float FallDamageAmount, bool CustomFallDamage) { return NativeCall<bool, FHitResult*, float, bool>(this, "APrimalDinoCharacter.AllowFallDamage", HitResult, FallDamageAmount, CustomFallDamage); }
    void ApplyDamageMomentum(float DamageTaken, FDamageEvent * DamageEvent, APawn * PawnInstigator, AActor * DamageCauser) { NativeCall<void, float, FDamageEvent*, APawn*, AActor*>(this, "APrimalDinoCharacter.ApplyDamageMomentum", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }
    void UpdateIK() { NativeCall<void>(this, "APrimalDinoCharacter.UpdateIK"); }
    bool AllowIKFreeze() { return NativeCall<bool>(this, "APrimalDinoCharacter.AllowIKFreeze"); }
    void SetSleeping(bool bSleeping, bool bUseRagdollLocationOffset) { NativeCall<void, bool, bool>(this, "APrimalDinoCharacter.SetSleeping", bSleeping, bUseRagdollLocationOffset); }
    bool Die(float KillingDamage, FDamageEvent * DamageEvent, AController * Killer, AActor * DamageCauser) { return NativeCall<bool, float, FDamageEvent*, AController*, AActor*>(this, "APrimalDinoCharacter.Die", KillingDamage, DamageEvent, Killer, DamageCauser); }
    bool AllowPenetrationCheck(AActor * OtherActor) { return NativeCall<bool, AActor*>(this, "APrimalDinoCharacter.AllowPenetrationCheck", OtherActor); }
    bool PreventCharacterBasing(AActor * OtherActor, UPrimitiveComponent * BasedOnComponent) { return NativeCall<bool, AActor*, UPrimitiveComponent*>(this, "APrimalDinoCharacter.PreventCharacterBasing", OtherActor, BasedOnComponent); }
    bool IsBasedOnActor(AActor * Other) { return NativeCall<bool, AActor*>(this, "APrimalDinoCharacter.IsBasedOnActor", Other); }
    void LoadedFromSaveGame() { NativeCall<void>(this, "APrimalDinoCharacter.LoadedFromSaveGame"); }
    float GetCorpseTargetingMultiplier() { return NativeCall<float>(this, "APrimalDinoCharacter.GetCorpseTargetingMultiplier"); }
    void UpdateStatusComponent(float DeltaSeconds) { NativeCall<void, float>(this, "APrimalDinoCharacter.UpdateStatusComponent", DeltaSeconds); }
    void CaptureCharacterSnapshot(UPrimalItem * Item) { NativeCall<void, UPrimalItem*>(this, "APrimalDinoCharacter.CaptureCharacterSnapshot", Item); }
    void ApplyCharacterSnapshot(UPrimalItem * Item, AActor * To, FVector Offset, float MaxExtent, int Pose) { NativeCall<void, UPrimalItem*, AActor*, FVector, float, int>(this, "APrimalDinoCharacter.ApplyCharacterSnapshot", Item, To, Offset, MaxExtent, Pose); }
    void TamedDinoUnstasisConsumeFood(long double ForceTimeSinceStasis) { NativeCall<void, long double>(this, "APrimalDinoCharacter.TamedDinoUnstasisConsumeFood", ForceTimeSinceStasis); }
    AActor * GetTamedFollowTarget() { return NativeCall<AActor*>(this, "APrimalDinoCharacter.GetTamedFollowTarget"); }
    AActor * GetTamedLandTarget() { return NativeCall<AActor*>(this, "APrimalDinoCharacter.GetTamedLandTarget"); }
    void ClearTamedLandTarget() { NativeCall<void>(this, "APrimalDinoCharacter.ClearTamedLandTarget"); }
    void DinoKillerTransferItemsToInventory(UPrimalInventoryComponent * FromInventory) { NativeCall<void, UPrimalInventoryComponent*>(this, "APrimalDinoCharacter.DinoKillerTransferItemsToInventory", FromInventory); }
    bool FlyingUseHighQualityCollision() { return NativeCall<bool>(this, "APrimalDinoCharacter.FlyingUseHighQualityCollision"); }
    bool AllowWalkableSlopeOverride(UPrimitiveComponent * ForComponent) { return NativeCall<bool, UPrimitiveComponent*>(this, "APrimalDinoCharacter.AllowWalkableSlopeOverride", ForComponent); }
    float GetCarryingSocketYaw(bool RefreshBones) { return NativeCall<float, bool>(this, "APrimalDinoCharacter.GetCarryingSocketYaw", RefreshBones); }
    void GetRidingCarryingIgnoreList(TArray<AActor*> * IgnoreList) { NativeCall<void, TArray<AActor*>*>(this, "APrimalDinoCharacter.GetRidingCarryingIgnoreList", IgnoreList); }
    void SetCarryingDino(APrimalDinoCharacter * aDino) { NativeCall<void, APrimalDinoCharacter*>(this, "APrimalDinoCharacter.SetCarryingDino", aDino); }
    void ClearCarryingDino(bool bFromDino, bool bCancelAnyCarryBuffs) { NativeCall<void, bool, bool>(this, "APrimalDinoCharacter.ClearCarryingDino", bFromDino, bCancelAnyCarryBuffs); }
    void UpdateCarriedLocationAndRotation(float DeltaSeconds) { NativeCall<void, float>(this, "APrimalDinoCharacter.UpdateCarriedLocationAndRotation", DeltaSeconds); }
    bool CanBeCarried(APrimalCharacter * ByCarrier) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalDinoCharacter.CanBeCarried", ByCarrier); }
    bool CanBeBaseForCharacter(APawn * Pawn) { return NativeCall<bool, APawn*>(this, "APrimalDinoCharacter.CanBeBaseForCharacter", Pawn); }
    void SetMountCharacter(APrimalCharacter * aCharacter) { NativeCall<void, APrimalCharacter*>(this, "APrimalDinoCharacter.SetMountCharacter", aCharacter); }
    void StartForceSkelUpdate(float ForTime, bool bForceUpdateMesh, bool bServerOnly) { NativeCall<void, float, bool, bool>(this, "APrimalDinoCharacter.StartForceSkelUpdate", ForTime, bForceUpdateMesh, bServerOnly); }
    void ClearMountCharacter(bool bFromMountCharacter) { NativeCall<void, bool>(this, "APrimalDinoCharacter.ClearMountCharacter", bFromMountCharacter); }
    bool CanMount(APrimalCharacter * aCharacter) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalDinoCharacter.CanMount", aCharacter); }
    static APrimalDinoCharacter * SpawnDino(UWorld * World, TSubclassOf<APrimalDinoCharacter> DinoClass, FVector SpawnLoc, FRotator SpawnRot, float LevelMultiplier, int ExtraLevelOffset, bool AddLevelOffsetBeforeMultiplier, bool bOverrideBaseNPCLevel, int BaseLevelOverrideValue, bool bNPCDontWander, float NPCAIRangeMultiplier, int NPCAbsoluteBaseLevel, bool bSpawnWithoutCapsuleOffset) { return NativeCall<APrimalDinoCharacter*, UWorld*, TSubclassOf<APrimalDinoCharacter>, FVector, FRotator, float, int, bool, bool, int, bool, float, int, bool>(nullptr, "APrimalDinoCharacter.SpawnDino", World, DinoClass, SpawnLoc, SpawnRot, LevelMultiplier, ExtraLevelOffset, AddLevelOffsetBeforeMultiplier, bOverrideBaseNPCLevel, BaseLevelOverrideValue, bNPCDontWander, NPCAIRangeMultiplier, NPCAbsoluteBaseLevel, bSpawnWithoutCapsuleOffset); }
    void UpdateNextAllowedMatingTime(long double fromTime) { NativeCall<void, long double>(this, "APrimalDinoCharacter.UpdateNextAllowedMatingTime", fromTime); }
    void SetNextAllowedMatingTime(long double nextAllowedMatingTime) { NativeCall<void, long double>(this, "APrimalDinoCharacter.SetNextAllowedMatingTime", nextAllowedMatingTime); }
    void InitDownloadedTamedDino(AShooterPlayerController * TamerController, int AltTeam) { NativeCall<void, AShooterPlayerController*, int>(this, "APrimalDinoCharacter.InitDownloadedTamedDino", TamerController, AltTeam); }
    void NetUpdateDinoOwnerData_Implementation(FString * NewOwningPlayerName, int NewOwningPlayerID) { NativeCall<void, FString*, int>(this, "APrimalDinoCharacter.NetUpdateDinoOwnerData_Implementation", NewOwningPlayerName, NewOwningPlayerID); }
    bool RemoteInventoryAllowViewing(APlayerController * ForPC) { return NativeCall<bool, APlayerController*>(this, "APrimalDinoCharacter.RemoteInventoryAllowViewing", ForPC); }
    bool ForceAllowBackwardsMovement() { return NativeCall<bool>(this, "APrimalDinoCharacter.ForceAllowBackwardsMovement"); }
    bool CanDragCharacter(APrimalCharacter * Character) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalDinoCharacter.CanDragCharacter", Character); }
    bool IsTaming() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsTaming"); }
    void UpdateWakingTame(float DeltaTime) { NativeCall<void, float>(this, "APrimalDinoCharacter.UpdateWakingTame", DeltaTime); }
    void FedWakingTameDino_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.FedWakingTameDino_Implementation"); }
    void AddStructure(APrimalStructure * Structure, FVector RelLoc, FRotator RelRot, FName BoneName) { NativeCall<void, APrimalStructure*, FVector, FRotator, FName>(this, "APrimalDinoCharacter.AddStructure", Structure, RelLoc, RelRot, BoneName); }
    void RemoveStructure(APrimalStructure * Structure) { NativeCall<void, APrimalStructure*>(this, "APrimalDinoCharacter.RemoveStructure", Structure); }
    void InitializeInvisiableSaddle() { NativeCall<void>(this, "APrimalDinoCharacter.InitializeInvisiableSaddle"); }
    int FindSaddleStructure(APrimalStructure * Structure) { return NativeCall<int, APrimalStructure*>(this, "APrimalDinoCharacter.FindSaddleStructure", Structure); }
    void OnRep_Saddle() { NativeCall<void>(this, "APrimalDinoCharacter.OnRep_Saddle"); }
    void RemoveSaddleAttachment(FItemNetID Id) { NativeCall<void, FItemNetID>(this, "APrimalDinoCharacter.RemoveSaddleAttachment", Id); }
    void ServerUploadCharacter(AShooterPlayerController * UploadedBy) { NativeCall<void, AShooterPlayerController*>(this, "APrimalDinoCharacter.ServerUploadCharacter", UploadedBy); }
    UAnimMontage * GetPoopAnimation(bool bForcePoop) { return NativeCall<UAnimMontage*, bool>(this, "APrimalDinoCharacter.GetPoopAnimation", bForcePoop); }
    void EmitPoop() { NativeCall<void>(this, "APrimalDinoCharacter.EmitPoop"); }
    void CheckForWildAmbientHarvesting() { NativeCall<void>(this, "APrimalDinoCharacter.CheckForWildAmbientHarvesting"); }
    void OverrideRandomWanderLocation_Implementation(FVector * originalDestination, FVector * inVec) { NativeCall<void, FVector*, FVector*>(this, "APrimalDinoCharacter.OverrideRandomWanderLocation_Implementation", originalDestination, inVec); }
    bool OverrideFinalWanderLocation_Implementation(FVector * outVec) { return NativeCall<bool, FVector*>(this, "APrimalDinoCharacter.OverrideFinalWanderLocation_Implementation", outVec); }
    void BPForceReachedDestination() { NativeCall<void>(this, "APrimalDinoCharacter.BPForceReachedDestination"); }
    bool AllowEquippingItemType(EPrimalEquipmentType::Type equipmentType) { return NativeCall<bool, EPrimalEquipmentType::Type>(this, "APrimalDinoCharacter.AllowEquippingItemType", equipmentType); }
    void OnPressProne() { NativeCall<void>(this, "APrimalDinoCharacter.OnPressProne"); }
    void OnReleaseProne() { NativeCall<void>(this, "APrimalDinoCharacter.OnReleaseProne"); }
    void OnPressReload() { NativeCall<void>(this, "APrimalDinoCharacter.OnPressReload"); }
    void OnPressCrouch() { NativeCall<void>(this, "APrimalDinoCharacter.OnPressCrouch"); }
    void OnReleaseCrouch() { NativeCall<void>(this, "APrimalDinoCharacter.OnReleaseCrouch"); }
    void DoDinoCrouch() { NativeCall<void>(this, "APrimalDinoCharacter.DoDinoCrouch"); }
    void OnPressCrouchProneToggle() { NativeCall<void>(this, "APrimalDinoCharacter.OnPressCrouchProneToggle"); }
    void OnReleaseCrouchProneToggle() { NativeCall<void>(this, "APrimalDinoCharacter.OnReleaseCrouchProneToggle"); }
    void NotifyBumpedPawn(APawn * BumpedPawn) { NativeCall<void, APawn*>(this, "APrimalDinoCharacter.NotifyBumpedPawn", BumpedPawn); }
    void NotifyBumpedStructure(AActor * BumpedStructure) { NativeCall<void, AActor*>(this, "APrimalDinoCharacter.NotifyBumpedStructure", BumpedStructure); }
    void DoDeathHarvestingFadeOut() { NativeCall<void>(this, "APrimalDinoCharacter.DoDeathHarvestingFadeOut"); }
    void StartRepair() { NativeCall<void>(this, "APrimalDinoCharacter.StartRepair"); }
    void RepairCheckTimer() { NativeCall<void>(this, "APrimalDinoCharacter.RepairCheckTimer"); }
    bool InitializeForReplicatedBasing() { return NativeCall<bool>(this, "APrimalDinoCharacter.InitializeForReplicatedBasing"); }
    void AddBasedPawn(AActor * anPawn) { NativeCall<void, AActor*>(this, "APrimalDinoCharacter.AddBasedPawn", anPawn); }
    void RemoveBasedPawn(AActor * anPawn) { NativeCall<void, AActor*>(this, "APrimalDinoCharacter.RemoveBasedPawn", anPawn); }
    bool AllowMovementMode(EMovementMode NewMovementMode, char NewCustomMode) { return NativeCall<bool, EMovementMode, char>(this, "APrimalDinoCharacter.AllowMovementMode", NewMovementMode, NewCustomMode); }
    void OnRep_bBonesHidden() { NativeCall<void>(this, "APrimalDinoCharacter.OnRep_bBonesHidden"); }
    void SetBabyAge(float TheAge) { NativeCall<void, float>(this, "APrimalDinoCharacter.SetBabyAge", TheAge); }
    void ApplyBoneModifiers(bool bForce, bool bForceOnDedicated) { NativeCall<void, bool, bool>(this, "APrimalDinoCharacter.ApplyBoneModifiers", bForce, bForceOnDedicated); }
    void ApplyGestationBoneModifiers() { NativeCall<void>(this, "APrimalDinoCharacter.ApplyGestationBoneModifiers"); }
    float GetAttachedSoundPitchMultiplier() { return NativeCall<float>(this, "APrimalDinoCharacter.GetAttachedSoundPitchMultiplier"); }
    float GetAttachedSoundVolumeMultiplier() { return NativeCall<float>(this, "APrimalDinoCharacter.GetAttachedSoundVolumeMultiplier"); }
    bool Poop(bool bForcePoop) { return NativeCall<bool, bool>(this, "APrimalDinoCharacter.Poop", bForcePoop); }
    float GetBaseDragWeight() { return NativeCall<float>(this, "APrimalDinoCharacter.GetBaseDragWeight"); }
    void ServerUpdateBabyAge(float overrideAgePercent) { NativeCall<void, float>(this, "APrimalDinoCharacter.ServerUpdateBabyAge", overrideAgePercent); }
    void ServerUpdateGestation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerUpdateGestation"); }
    float GetHealthPercentage() { return NativeCall<float>(this, "APrimalDinoCharacter.GetHealthPercentage"); }
    void UpdateMating() { NativeCall<void>(this, "APrimalDinoCharacter.UpdateMating"); }
    void DoMate(APrimalDinoCharacter * WithMate) { NativeCall<void, APrimalDinoCharacter*>(this, "APrimalDinoCharacter.DoMate", WithMate); }
    ADroppedItem * CreateCloneFertilizedEgg(FVector AtLoc, FRotator AtRot, TSubclassOf<ADroppedItem> DroppedItemTemplateOverride) { return NativeCall<ADroppedItem*, FVector, FRotator, TSubclassOf<ADroppedItem>>(this, "APrimalDinoCharacter.CreateCloneFertilizedEgg", AtLoc, AtRot, DroppedItemTemplateOverride); }
    FVector * GetInterpolatedLocation(FVector * result) { return NativeCall<FVector*, FVector*>(this, "APrimalDinoCharacter.GetInterpolatedLocation", result); }
    static APrimalDinoCharacter * BPStaticCreateBabyDinoNoAncestors(UWorld * TheWorld, TSubclassOf<APrimalDinoCharacter> EggDinoClassToSpawn, FVector * theGroundLoc, float actorRotationYaw, TArray<unsigned char> EggColorSetIndices, TArray<unsigned char> EggNumberOfLevelUpPointsApplied, float EggTamedIneffectivenessModifier, int NotifyTeamOverride, int EggRandomMutationsFemale, int EggRandomMutationsMale) { return NativeCall<APrimalDinoCharacter*, UWorld*, TSubclassOf<APrimalDinoCharacter>, FVector*, float, TArray<unsigned char>, TArray<unsigned char>, float, int, int, int>(nullptr, "APrimalDinoCharacter.BPStaticCreateBabyDinoNoAncestors", TheWorld, EggDinoClassToSpawn, theGroundLoc, actorRotationYaw, EggColorSetIndices, EggNumberOfLevelUpPointsApplied, EggTamedIneffectivenessModifier, NotifyTeamOverride, EggRandomMutationsFemale, EggRandomMutationsMale); }
    static APrimalDinoCharacter * BPStaticCreateBabyDino(UWorld * TheWorld, TSubclassOf<APrimalDinoCharacter> EggDinoClassToSpawn, FVector * theGroundLoc, float actorRotationYaw, TArray<unsigned char> EggColorSetIndices, TArray<unsigned char> EggNumberOfLevelUpPointsApplied, float EggTamedIneffectivenessModifier, TArray<FDinoAncestorsEntry> EggDinoAncestors, TArray<FDinoAncestorsEntry> EggDinoAncestorsMale, int NotifyTeamOverride, int EggRandomMutationsFemale, int EggRandomMutationsMale) { return NativeCall<APrimalDinoCharacter*, UWorld*, TSubclassOf<APrimalDinoCharacter>, FVector*, float, TArray<unsigned char>, TArray<unsigned char>, float, TArray<FDinoAncestorsEntry>, TArray<FDinoAncestorsEntry>, int, int, int>(nullptr, "APrimalDinoCharacter.BPStaticCreateBabyDino", TheWorld, EggDinoClassToSpawn, theGroundLoc, actorRotationYaw, EggColorSetIndices, EggNumberOfLevelUpPointsApplied, EggTamedIneffectivenessModifier, EggDinoAncestors, EggDinoAncestorsMale, NotifyTeamOverride, EggRandomMutationsFemale, EggRandomMutationsMale); }
    static APrimalDinoCharacter * StaticCreateBabyDino(UWorld * theWorld, TSubclassOf<APrimalDinoCharacter> EggDinoClassToSpawn, FVector * theGroundLoc, float actorRotationYaw, char* EggColorSetIndices, char* EggNumberOfLevelUpPointsApplied, float EggTamedIneffectivenessModifier, int NotifyTeamOverride, TArray<FDinoAncestorsEntry> * EggDinoAncestors, TArray<FDinoAncestorsEntry> * EggDinoAncestorsMale, int EggRandomMutationsFemale, int EggRandomMutationsMale) { return NativeCall<APrimalDinoCharacter*, UWorld*, TSubclassOf<APrimalDinoCharacter>, FVector*, float, char*, char*, float, int, TArray<FDinoAncestorsEntry>*, TArray<FDinoAncestorsEntry>*, int, int>(nullptr, "APrimalDinoCharacter.StaticCreateBabyDino", theWorld, EggDinoClassToSpawn, theGroundLoc, actorRotationYaw, EggColorSetIndices, EggNumberOfLevelUpPointsApplied, EggTamedIneffectivenessModifier, NotifyTeamOverride, EggDinoAncestors, EggDinoAncestorsMale, EggRandomMutationsFemale, EggRandomMutationsMale); }
    FVector * GetDinoVelocity(FVector * result) { return NativeCall<FVector*, FVector*>(this, "APrimalDinoCharacter.GetDinoVelocity", result); }
    void UpdateGang() { NativeCall<void>(this, "APrimalDinoCharacter.UpdateGang"); }
    bool WantsPerFrameSkeletalAnimationTicking() { return NativeCall<bool>(this, "APrimalDinoCharacter.WantsPerFrameSkeletalAnimationTicking"); }
    bool BPIsTamed() { return NativeCall<bool>(this, "APrimalDinoCharacter.BPIsTamed"); }
    TSubclassOf<UDamageType> * BlueprintOverrideHarvestDamageType_Implementation(TSubclassOf<UDamageType> * result, float* OutHarvestDamageMultiplier) { return NativeCall<TSubclassOf<UDamageType>*, TSubclassOf<UDamageType>*, float*>(this, "APrimalDinoCharacter.BlueprintOverrideHarvestDamageType_Implementation", result, OutHarvestDamageMultiplier); }
    bool ShouldForceFlee() { return NativeCall<bool>(this, "APrimalDinoCharacter.ShouldForceFlee"); }
    float GetGravityZScale() { return NativeCall<float>(this, "APrimalDinoCharacter.GetGravityZScale"); }
    bool ForceAllowAccelerationRotationWhenFalling() { return NativeCall<bool>(this, "APrimalDinoCharacter.ForceAllowAccelerationRotationWhenFalling"); }
    bool ShouldDisableControllerDesiredRotation() { return NativeCall<bool>(this, "APrimalDinoCharacter.ShouldDisableControllerDesiredRotation"); }
    bool AllowExtendedCraftingFunctionality() { return NativeCall<bool>(this, "APrimalDinoCharacter.AllowExtendedCraftingFunctionality"); }
    void ClearCharacterAIMovement() { NativeCall<void>(this, "APrimalDinoCharacter.ClearCharacterAIMovement"); }
    void UpdateTribeGroupRanks_Implementation(char NewTribeGroupPetOrderingRank, char NewTribeGroupPetRidingRank) { NativeCall<void, char, char>(this, "APrimalDinoCharacter.UpdateTribeGroupRanks_Implementation", NewTribeGroupPetOrderingRank, NewTribeGroupPetRidingRank); }
    FVector * GetFloatingHUDLocation(FVector * result) { return NativeCall<FVector*, FVector*>(this, "APrimalDinoCharacter.GetFloatingHUDLocation", result); }
    void WasPushed(ACharacter * ByOtherCharacter) { NativeCall<void, ACharacter*>(this, "APrimalDinoCharacter.WasPushed", ByOtherCharacter); }
    float GetAIFollowStoppingDistanceMultiplier() { return NativeCall<float>(this, "APrimalDinoCharacter.GetAIFollowStoppingDistanceMultiplier"); }
    float GetAIFollowStoppingDistanceOffset() { return NativeCall<float>(this, "APrimalDinoCharacter.GetAIFollowStoppingDistanceOffset"); }
    FVector * GetSocketLocationTemp(FVector * result, FName SocketName) { return NativeCall<FVector*, FVector*, FName>(this, "APrimalDinoCharacter.GetSocketLocationTemp", result, SocketName); }
    void SetMovementAccelerationVector(FVector fVector) { NativeCall<void, FVector>(this, "APrimalDinoCharacter.SetMovementAccelerationVector", fVector); }
    bool GetForceTickPose() { return NativeCall<bool>(this, "APrimalDinoCharacter.GetForceTickPose"); }
    bool PlayedAnimationHasAttack() { return NativeCall<bool>(this, "APrimalDinoCharacter.PlayedAnimationHasAttack"); }
    bool BPGetAttackOfPlayedAnimation(FDinoAttackInfo * OutAttackInfo) { return NativeCall<bool, FDinoAttackInfo*>(this, "APrimalDinoCharacter.BPGetAttackOfPlayedAnimation", OutAttackInfo); }
    bool ShouldAttackOfPlayedAnimationStopMovement() { return NativeCall<bool>(this, "APrimalDinoCharacter.ShouldAttackOfPlayedAnimationStopMovement"); }
    void SetPreventSaving(bool fPreventSaving) { NativeCall<void, bool>(this, "APrimalDinoCharacter.SetPreventSaving", fPreventSaving); }
    void SetStasisComponentRadius(float StasisOverrideRadius) { NativeCall<void, float>(this, "APrimalDinoCharacter.SetStasisComponentRadius", StasisOverrideRadius); }
    void UpdateImprintingDetailsForController(AShooterPlayerController * controller) { NativeCall<void, AShooterPlayerController*>(this, "APrimalDinoCharacter.UpdateImprintingDetailsForController", controller); }
    void UpdateImprintingDetails_Implementation(FString * NewImprinterName, unsigned __int64 NewImprinterPlayerDataID) { NativeCall<void, FString*, unsigned __int64>(this, "APrimalDinoCharacter.UpdateImprintingDetails_Implementation", NewImprinterName, NewImprinterPlayerDataID); }
    void UpdateImprintingQuality_Implementation(float NewImprintingQuality) { NativeCall<void, float>(this, "APrimalDinoCharacter.UpdateImprintingQuality_Implementation", NewImprintingQuality); }
    void UpdateBabyCuddling_Implementation(long double NewBabyNextCuddleTime, char NewBabyCuddleType, TSubclassOf<UPrimalItem> NewBabyCuddleFood) { NativeCall<void, long double, char, TSubclassOf<UPrimalItem>>(this, "APrimalDinoCharacter.UpdateBabyCuddling_Implementation", NewBabyNextCuddleTime, NewBabyCuddleType, NewBabyCuddleFood); }
    TSubclassOf<UPrimalItem> * GetBabyCuddleFood(TSubclassOf<UPrimalItem> * result) { return NativeCall<TSubclassOf<UPrimalItem>*, TSubclassOf<UPrimalItem>*>(this, "APrimalDinoCharacter.GetBabyCuddleFood", result); }
    void IncrementImprintingQuality() { NativeCall<void>(this, "APrimalDinoCharacter.IncrementImprintingQuality"); }
    void AddedImprintingQuality_Implementation(float Amount) { NativeCall<void, float>(this, "APrimalDinoCharacter.AddedImprintingQuality_Implementation", Amount); }
    bool AllowWakingTame_Implementation(APlayerController * ForPC) { return NativeCall<bool, APlayerController*>(this, "APrimalDinoCharacter.AllowWakingTame_Implementation", ForPC); }
    float GetBaseTargetingDesire(ITargetableInterface * Attacker) { return NativeCall<float, ITargetableInterface*>(this, "APrimalDinoCharacter.GetBaseTargetingDesire", Attacker); }
    bool BPAllowEquippingItemType_Implementation(EPrimalEquipmentType::Type equipmentType) { return NativeCall<bool, EPrimalEquipmentType::Type>(this, "APrimalDinoCharacter.BPAllowEquippingItemType_Implementation", equipmentType); }
    void UpdateUnstasisFlags() { NativeCall<void>(this, "APrimalDinoCharacter.UpdateUnstasisFlags"); }
    void UpdateStasisFlags() { NativeCall<void>(this, "APrimalDinoCharacter.UpdateStasisFlags"); }
    bool IsVehicle() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsVehicle"); }
    void DestroyController() { NativeCall<void>(this, "APrimalDinoCharacter.DestroyController"); }
    void PostNetReceiveLocationAndRotation() { NativeCall<void>(this, "APrimalDinoCharacter.PostNetReceiveLocationAndRotation"); }
    void ResetTakingOff() { NativeCall<void>(this, "APrimalDinoCharacter.ResetTakingOff"); }
    void RemoveFromMeleeSwingHurtList(AActor * AnActor) { NativeCall<void, AActor*>(this, "APrimalDinoCharacter.RemoveFromMeleeSwingHurtList", AnActor); }
    void FireMultipleProjectiles_Implementation(TArray<FVector> * Locations, TArray<FVector> * Directions, bool bScaleProjectileDamageByDinoDamage) { NativeCall<void, TArray<FVector>*, TArray<FVector>*, bool>(this, "APrimalDinoCharacter.FireMultipleProjectiles_Implementation", Locations, Directions, bScaleProjectileDamageByDinoDamage); }
    bool IsMissionDino() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsMissionDino"); }
    void CycleAttackWeightsForAttackAtIndex(int attackIndex) { NativeCall<void, int>(this, "APrimalDinoCharacter.CycleAttackWeightsForAttackAtIndex", attackIndex); }
    void SetAnimWeightsForAttackAtIndex(int attackIndex, TArray<float> newWeights) { NativeCall<void, int, TArray<float>>(this, "APrimalDinoCharacter.SetAnimWeightsForAttackAtIndex", attackIndex, newWeights); }
    AShooterCharacter * BPConsumeInventoryFoodItem(UPrimalItem * foodItem, bool bConsumeEntireStack) { return NativeCall<AShooterCharacter*, UPrimalItem*, bool>(this, "APrimalDinoCharacter.BPConsumeInventoryFoodItem", foodItem, bConsumeEntireStack); }
    void AddDinoReferenceInLatchingStructure(APrimalStructure * Structure) { NativeCall<void, APrimalStructure*>(this, "APrimalDinoCharacter.AddDinoReferenceInLatchingStructure", Structure); }
    void RemoveDinoReferenceFromLatchingStructure() { NativeCall<void>(this, "APrimalDinoCharacter.RemoveDinoReferenceFromLatchingStructure"); }
    bool HasTarget() { return NativeCall<bool>(this, "APrimalDinoCharacter.HasTarget"); }
    UPrimalItem * GiveSaddle(TSubclassOf<UPrimalItem> SaddleType, float Quality, float MinRandomQuality, bool bAutoEquip) { return NativeCall<UPrimalItem*, TSubclassOf<UPrimalItem>, float, float, bool>(this, "APrimalDinoCharacter.GiveSaddle", SaddleType, Quality, MinRandomQuality, bAutoEquip); }
    UPrimalItem * GiveSaddleFromString(FString * BlueprintPath, float Quality, float MinRandomQuality, bool bAutoEquip) { return NativeCall<UPrimalItem*, FString*, float, float, bool>(this, "APrimalDinoCharacter.GiveSaddleFromString", BlueprintPath, Quality, MinRandomQuality, bAutoEquip); }
    void StartSurfaceCameraForPassengers(float yaw, float pitch, float roll) { NativeCall<void, float, float, float>(this, "APrimalDinoCharacter.StartSurfaceCameraForPassengers", yaw, pitch, roll); }
    void StartSurfaceCameraForPassenger(AShooterCharacter * Passenger, float yaw, float pitch, float roll, bool bInvertTurnInput) { NativeCall<void, AShooterCharacter*, float, float, float, bool>(this, "APrimalDinoCharacter.StartSurfaceCameraForPassenger", Passenger, yaw, pitch, roll, bInvertTurnInput); }
    TArray<APrimalCharacter*> * GetPassengers(TArray<APrimalCharacter*> * result) { return NativeCall<TArray<APrimalCharacter*>*, TArray<APrimalCharacter*>*>(this, "APrimalDinoCharacter.GetPassengers", result); }
    void GetPassengersAndSeatIndexes(TArray<APrimalCharacter*> * Passengers, TArray<int> * Indexes) { NativeCall<void, TArray<APrimalCharacter*>*, TArray<int>*>(this, "APrimalDinoCharacter.GetPassengersAndSeatIndexes", Passengers, Indexes); }
    int GetPassengersSeatIndex(APrimalCharacter * Passenger) { return NativeCall<int, APrimalCharacter*>(this, "APrimalDinoCharacter.GetPassengersSeatIndex", Passenger); }
    bool ShouldIgnoreMoveCombiningOverlap() { return NativeCall<bool>(this, "APrimalDinoCharacter.ShouldIgnoreMoveCombiningOverlap"); }
    bool AllowMountedWeaponry(bool bIgnoreCurrentWeapon, bool bWeaponForcesMountedWeaponry) { return NativeCall<bool, bool, bool>(this, "APrimalDinoCharacter.AllowMountedWeaponry", bIgnoreCurrentWeapon, bWeaponForcesMountedWeaponry); }
    void ModifyDesiredRotation(FRotator * InDesiredRotation) { NativeCall<void, FRotator*>(this, "APrimalDinoCharacter.ModifyDesiredRotation", InDesiredRotation); }
    void GiveDeathDossier() { NativeCall<void>(this, "APrimalDinoCharacter.GiveDeathDossier"); }
    void ServerSetRiderMountedWeaponRotation_Implementation(FRotator InVal) { NativeCall<void, FRotator>(this, "APrimalDinoCharacter.ServerSetRiderMountedWeaponRotation_Implementation", InVal); }
    void DoNeuter_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.DoNeuter_Implementation"); }
    float BPModifyHarvestingQuantity_Implementation(float originalQuantity, TSubclassOf<UPrimalItem> resourceSelected) { return NativeCall<float, float, TSubclassOf<UPrimalItem>>(this, "APrimalDinoCharacter.BPModifyHarvestingQuantity_Implementation", originalQuantity, resourceSelected); }
    float BPModifyHarvestDamage_Implementation(UPrimalHarvestingComponent * harvestComponent, float inDamage) { return NativeCall<float, UPrimalHarvestingComponent*, float>(this, "APrimalDinoCharacter.BPModifyHarvestDamage_Implementation", harvestComponent, inDamage); }
    bool OverrideForcePreventExitingWater() { return NativeCall<bool>(this, "APrimalDinoCharacter.OverrideForcePreventExitingWater"); }
    APrimalStructureExplosive * GetAttachedExplosive() { return NativeCall<APrimalStructureExplosive*>(this, "APrimalDinoCharacter.GetAttachedExplosive"); }
    void OnStopTargeting(bool bFromGamepadLeft) { NativeCall<void, bool>(this, "APrimalDinoCharacter.OnStopTargeting", bFromGamepadLeft); }
    void SetDynamicMusic(USoundBase * newMusic) { NativeCall<void, USoundBase*>(this, "APrimalDinoCharacter.SetDynamicMusic", newMusic); }
    FLinearColor * GetDinoColor(FLinearColor * result, int ColorRegionIndex) { return NativeCall<FLinearColor*, FLinearColor*, int>(this, "APrimalDinoCharacter.GetDinoColor", result, ColorRegionIndex); }
    FLinearColor * GetColorForColorizationRegion(FLinearColor * result, int ColorRegionIndex, int ColorIndexOverride) { return NativeCall<FLinearColor*, FLinearColor*, int, int>(this, "APrimalDinoCharacter.GetColorForColorizationRegion", result, ColorRegionIndex, ColorIndexOverride); }
    bool SpecialActorWantsPerFrameTicking() { return NativeCall<bool>(this, "APrimalDinoCharacter.SpecialActorWantsPerFrameTicking"); }
    int IsActorTickAllowed() { return NativeCall<int>(this, "APrimalDinoCharacter.IsActorTickAllowed"); }
    void IncrementNumTamedDinos() { NativeCall<void>(this, "APrimalDinoCharacter.IncrementNumTamedDinos"); }
    UAnimMontage * GetDinoLevelUpAnimation_Implementation() { return NativeCall<UAnimMontage*>(this, "APrimalDinoCharacter.GetDinoLevelUpAnimation_Implementation"); }
    bool ShouldStillAllowRequestedMoveAcceleration() { return NativeCall<bool>(this, "APrimalDinoCharacter.ShouldStillAllowRequestedMoveAcceleration"); }
    bool AreSpawnerSublevelsLoaded() { return NativeCall<bool>(this, "APrimalDinoCharacter.AreSpawnerSublevelsLoaded"); }
    void SetLastMovementDesiredRotation(FRotator * InRotation) { NativeCall<void, FRotator*>(this, "APrimalDinoCharacter.SetLastMovementDesiredRotation", InRotation); }
    USoundBase * GetDinoTameSound_Implementation() { return NativeCall<USoundBase*>(this, "APrimalDinoCharacter.GetDinoTameSound_Implementation"); }
    bool AllowTickPhysics() { return NativeCall<bool>(this, "APrimalDinoCharacter.AllowTickPhysics"); }
    void CheckForTamedFoodConsumption(int Steps) { NativeCall<void, int>(this, "APrimalDinoCharacter.CheckForTamedFoodConsumption", Steps); }
    long double GetDinoDeathTime() { return NativeCall<long double>(this, "APrimalDinoCharacter.GetDinoDeathTime"); }
    bool ShouldIgnoreHitResult(UWorld * InWorld, FHitResult * TestHit, FVector * MovementDirDenormalized) { return NativeCall<bool, UWorld*, FHitResult*, FVector*>(this, "APrimalDinoCharacter.ShouldIgnoreHitResult", InWorld, TestHit, MovementDirDenormalized); }
    bool WalkingAllowCheckFloor(FVector * DeltaWalk) { return NativeCall<bool, FVector*>(this, "APrimalDinoCharacter.WalkingAllowCheckFloor", DeltaWalk); }
    bool WalkingAllowCheckFall(FVector * DeltaWalk) { return NativeCall<bool, FVector*>(this, "APrimalDinoCharacter.WalkingAllowCheckFall", DeltaWalk); }
    float GetGestationTimeRemaining() { return NativeCall<float>(this, "APrimalDinoCharacter.GetGestationTimeRemaining"); }
    int GetTamedDinoCountCost() { return NativeCall<int>(this, "APrimalDinoCharacter.GetTamedDinoCountCost"); }
    void ClearAllSaddleStructures() { NativeCall<void>(this, "APrimalDinoCharacter.ClearAllSaddleStructures"); }
    bool IsReadyToUpload(UWorld * theWorld) { return NativeCall<bool, UWorld*>(this, "APrimalDinoCharacter.IsReadyToUpload", theWorld); }
    void ImprintOnPlayerTarget(AShooterPlayerController * ForPC, bool bIgnoreMaxTameLimit) { NativeCall<void, AShooterPlayerController*, bool>(this, "APrimalDinoCharacter.ImprintOnPlayerTarget", ForPC, bIgnoreMaxTameLimit); }
    bool IsImprintPlayer(AShooterCharacter * ForChar) { return NativeCall<bool, AShooterCharacter*>(this, "APrimalDinoCharacter.IsImprintPlayer", ForChar); }
    void SetImprintPlayer(AShooterCharacter * ForChar) { NativeCall<void, AShooterCharacter*>(this, "APrimalDinoCharacter.SetImprintPlayer", ForChar); }
    void BPNotifyNameEditText(AShooterPlayerController * ForPC) { NativeCall<void, AShooterPlayerController*>(this, "APrimalDinoCharacter.BPNotifyNameEditText", ForPC); }
    void SetRidingDinoAsPassenger(APrimalDinoCharacter * aDino, FSaddlePassengerSeatDefinition * SeatDefinition) { NativeCall<void, APrimalDinoCharacter*, FSaddlePassengerSeatDefinition*>(this, "APrimalDinoCharacter.SetRidingDinoAsPassenger", aDino, SeatDefinition); }
    void ClearRidingDinoAsPassenger(bool bFromDino) { NativeCall<void, bool>(this, "APrimalDinoCharacter.ClearRidingDinoAsPassenger", bFromDino); }
    APrimalCharacter * GetPassengerPerSeat(int SeatIndex) { return NativeCall<APrimalCharacter*, int>(this, "APrimalDinoCharacter.GetPassengerPerSeat", SeatIndex); }
    void SetLastAttackTimeForAttack(int AttackIndex, long double NewTime) { NativeCall<void, int, long double>(this, "APrimalDinoCharacter.SetLastAttackTimeForAttack", AttackIndex, NewTime); }
    int GetSeatIndexForPassenger(APrimalCharacter * PassengerChar) { return NativeCall<int, APrimalCharacter*>(this, "APrimalDinoCharacter.GetSeatIndexForPassenger", PassengerChar); }
    bool IsPrimalCharFriendly(APrimalCharacter * primalChar) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalDinoCharacter.IsPrimalCharFriendly", primalChar); }
    void PrepareForSaving() { NativeCall<void>(this, "APrimalDinoCharacter.PrepareForSaving"); }
    void FinalLoadedFromSaveGame() { NativeCall<void>(this, "APrimalDinoCharacter.FinalLoadedFromSaveGame"); }
    void RefreshBabyScaling() { NativeCall<void>(this, "APrimalDinoCharacter.RefreshBabyScaling"); }
    FString * GetDebugInfoString(FString * result) { return NativeCall<FString*, FString*>(this, "APrimalDinoCharacter.GetDebugInfoString", result); }
    void GetDinoIDs(int* OutDinoID1, int* OutDinoID2) { NativeCall<void, int*, int*>(this, "APrimalDinoCharacter.GetDinoIDs", OutDinoID1, OutDinoID2); }
    void GetDinoIDsAsStrings(FString * OutDinoID1, FString * OutDinoID2) { NativeCall<void, FString*, FString*>(this, "APrimalDinoCharacter.GetDinoIDsAsStrings", OutDinoID1, OutDinoID2); }
    bool IsDeprecated() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsDeprecated"); }
    void DeferredDeprecationCheck() { NativeCall<void>(this, "APrimalDinoCharacter.DeferredDeprecationCheck"); }
    bool IsActiveEventDino() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsActiveEventDino"); }
    bool GetAllAttachedCharsInternal(TSet<APrimalCharacter*,DefaultKeyFuncs<APrimalCharacter*,0>,FDefaultSetAllocator> * AttachedChars, APrimalCharacter * OriginalChar, const bool bIncludeBased, const bool bIncludePassengers, const bool bIncludeCarried) { return NativeCall<bool, TSet<APrimalCharacter*,DefaultKeyFuncs<APrimalCharacter*,0>,FDefaultSetAllocator>*, APrimalCharacter*, const bool, const bool, const bool>(this, "APrimalDinoCharacter.GetAllAttachedCharsInternal", AttachedChars, OriginalChar, bIncludeBased, bIncludePassengers, bIncludeCarried); }
    bool ShouldForceDedicatedMovementTickEveryFrame() { return NativeCall<bool>(this, "APrimalDinoCharacter.ShouldForceDedicatedMovementTickEveryFrame"); }
    bool ShouldShowDinoTooltip(AShooterHUD * HUD) { return NativeCall<bool, AShooterHUD*>(this, "APrimalDinoCharacter.ShouldShowDinoTooltip", HUD); }
    void OverrideBasedCharactersCameraInterpSpeed(APrimalCharacter * ForBasedChar, const float DefaultTPVCameraSpeedInterpMultiplier, const float DefaultTPVOffsetInterpSpeed, float* TPVCameraSpeedInterpMultiplier, float* TPVOffsetInterpSpeed) { NativeCall<void, APrimalCharacter*, const float, const float, float*, float*>(this, "APrimalDinoCharacter.OverrideBasedCharactersCameraInterpSpeed", ForBasedChar, DefaultTPVCameraSpeedInterpMultiplier, DefaultTPVOffsetInterpSpeed, TPVCameraSpeedInterpMultiplier, TPVOffsetInterpSpeed); }
    bool ShouldDisableBasedCharactersCameraInterpolation(APrimalCharacter * ForBasedChar) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalDinoCharacter.ShouldDisableBasedCharactersCameraInterpolation", ForBasedChar); }
    bool CanDinoAttackTargetsWithoutRider() { return NativeCall<bool>(this, "APrimalDinoCharacter.CanDinoAttackTargetsWithoutRider"); }
    void ClearControlInputVector() { NativeCall<void>(this, "APrimalDinoCharacter.ClearControlInputVector"); }
    void CopyPaintingComponentFrom(APrimalDinoCharacter * Other) { NativeCall<void, APrimalDinoCharacter*>(this, "APrimalDinoCharacter.CopyPaintingComponentFrom", Other); }
    void PerformanceThrottledTick_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.PerformanceThrottledTick_Implementation"); }
    void OnVersionChange(bool* doDestroy) { NativeCall<void, bool*>(this, "APrimalDinoCharacter.OnVersionChange", doDestroy); }
    bool BPIsValidUnStasisCaster() { return NativeCall<bool>(this, "APrimalDinoCharacter.BPIsValidUnStasisCaster"); }
    static void StaticRegisterNativesAPrimalDinoCharacter() { NativeCall<void>(nullptr, "APrimalDinoCharacter.StaticRegisterNativesAPrimalDinoCharacter"); }
    static UClass * GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "APrimalDinoCharacter.GetPrivateStaticClass", Package); }
    void AddedImprintingQuality(float Amount) { NativeCall<void, float>(this, "APrimalDinoCharacter.AddedImprintingQuality", Amount); }
    bool AllowWakingTame(APlayerController * ForPC) { return NativeCall<bool, APlayerController*>(this, "APrimalDinoCharacter.AllowWakingTame", ForPC); }
    void AnimNotifyMountedDino() { NativeCall<void>(this, "APrimalDinoCharacter.AnimNotifyMountedDino"); }
    float BlueprintAdjustOutputDamage(int AttackIndex, float OriginalDamageAmount, AActor * HitActor, TSubclassOf<UDamageType> * OutDamageType, float* OutDamageImpulse) { return NativeCall<float, int, float, AActor*, TSubclassOf<UDamageType>*, float*>(this, "APrimalDinoCharacter.BlueprintAdjustOutputDamage", AttackIndex, OriginalDamageAmount, HitActor, OutDamageType, OutDamageImpulse); }
    bool BlueprintCanAttack(int AttackIndex, float distance, float attackRangeOffset, AActor * OtherTarget) { return NativeCall<bool, int, float, float, AActor*>(this, "APrimalDinoCharacter.BlueprintCanAttack", AttackIndex, distance, attackRangeOffset, OtherTarget); }
    bool BlueprintCanRiderAttack(int AttackIndex) { return NativeCall<bool, int>(this, "APrimalDinoCharacter.BlueprintCanRiderAttack", AttackIndex); }
    void BlueprintDrawFloatingHUD(AShooterHUD * HUD, float CenterX, float CenterY, float DrawScale) { NativeCall<void, AShooterHUD*, float, float, float>(this, "APrimalDinoCharacter.BlueprintDrawFloatingHUD", HUD, CenterX, CenterY, DrawScale); }
    float BlueprintExtraBabyScaling() { return NativeCall<float>(this, "APrimalDinoCharacter.BlueprintExtraBabyScaling"); }
    float BlueprintGetAttackWeight(int AttackIndex, float inputWeight, float distance, float attackRangeOffset, AActor * OtherTarget) { return NativeCall<float, int, float, float, float, AActor*>(this, "APrimalDinoCharacter.BlueprintGetAttackWeight", AttackIndex, inputWeight, distance, attackRangeOffset, OtherTarget); }
    TSubclassOf<UDamageType> * BlueprintOverrideHarvestDamageType(TSubclassOf<UDamageType> * result, float* OutHarvestDamageMultiplier) { return NativeCall<TSubclassOf<UDamageType>*, TSubclassOf<UDamageType>*, float*>(this, "APrimalDinoCharacter.BlueprintOverrideHarvestDamageType", result, OutHarvestDamageMultiplier); }
    bool BlueprintOverrideWantsToRun(bool bInputWantsToRun) { return NativeCall<bool, bool>(this, "APrimalDinoCharacter.BlueprintOverrideWantsToRun", bInputWantsToRun); }
    void BlueprintPlayDying(float KillingDamage, FDamageEvent * DamageEvent, APawn * InstigatingPawn, AActor * DamageCauser) { NativeCall<void, float, FDamageEvent*, APawn*, AActor*>(this, "APrimalDinoCharacter.BlueprintPlayDying", KillingDamage, DamageEvent, InstigatingPawn, DamageCauser); }
    void BlueprintTamedTick() { NativeCall<void>(this, "APrimalDinoCharacter.BlueprintTamedTick"); }
    bool BP_AllowWalkableSlopeOverride(UPrimitiveComponent * ForComponent) { return NativeCall<bool, UPrimitiveComponent*>(this, "APrimalDinoCharacter.BP_AllowWalkableSlopeOverride", ForComponent); }
    bool BP_CanFly() { return NativeCall<bool>(this, "APrimalDinoCharacter.BP_CanFly"); }
    float BP_GetCustomModifier_MaxSpeed() { return NativeCall<float>(this, "APrimalDinoCharacter.BP_GetCustomModifier_MaxSpeed"); }
    float BP_GetCustomModifier_RotationRate() { return NativeCall<float>(this, "APrimalDinoCharacter.BP_GetCustomModifier_RotationRate"); }
    bool BP_InterceptMoveForward(float axisValue) { return NativeCall<bool, float>(this, "APrimalDinoCharacter.BP_InterceptMoveForward", axisValue); }
    bool BP_InterceptMoveRight(float axisValue) { return NativeCall<bool, float>(this, "APrimalDinoCharacter.BP_InterceptMoveRight", axisValue); }
    bool BP_InterceptTurnInput(float axisValue) { return NativeCall<bool, float>(this, "APrimalDinoCharacter.BP_InterceptTurnInput", axisValue); }
    void BP_OnBasedPawnAddedNotify(AActor * AddedActor) { NativeCall<void, AActor*>(this, "APrimalDinoCharacter.BP_OnBasedPawnAddedNotify", AddedActor); }
    void BP_OnBasedPawnRemovedNotify(AActor * RemovedActor) { NativeCall<void, AActor*>(this, "APrimalDinoCharacter.BP_OnBasedPawnRemovedNotify", RemovedActor); }
    void BP_OnLandingInterruptedNotify() { NativeCall<void>(this, "APrimalDinoCharacter.BP_OnLandingInterruptedNotify"); }
    void BP_OnPostNetReplication(FVector ReplicatedLoc, FRotator ReplicatedRot) { NativeCall<void, FVector, FRotator>(this, "APrimalDinoCharacter.BP_OnPostNetReplication", ReplicatedLoc, ReplicatedRot); }
    void BP_OnRiderChangeWeapons(AShooterCharacter * theRider, UPrimalItem * newWeapon) { NativeCall<void, AShooterCharacter*, UPrimalItem*>(this, "APrimalDinoCharacter.BP_OnRiderChangeWeapons", theRider, newWeapon); }
    void BP_OnStartLandFailed(int ReasonIndex) { NativeCall<void, int>(this, "APrimalDinoCharacter.BP_OnStartLandFailed", ReasonIndex); }
    void BP_OnStartLandingNotify() { NativeCall<void>(this, "APrimalDinoCharacter.BP_OnStartLandingNotify"); }
    void BP_OnTamedOrderReceived(APrimalCharacter * FromCharacter, EDinoTamedOrder::Type OrderType, bool bForce, AActor * enemyTarget, bool orderNotExecuted) { NativeCall<void, APrimalCharacter*, EDinoTamedOrder::Type, bool, AActor*, bool>(this, "APrimalDinoCharacter.BP_OnTamedOrderReceived", FromCharacter, OrderType, bForce, enemyTarget, orderNotExecuted); }
    void BP_OnTargetedByTamedOrder(APrimalCharacter * OrderingCharacter, APrimalDinoCharacter * AttackingDino, bool bForced) { NativeCall<void, APrimalCharacter*, APrimalDinoCharacter*, bool>(this, "APrimalDinoCharacter.BP_OnTargetedByTamedOrder", OrderingCharacter, AttackingDino, bForced); }
    void BP_OverrideBasedCharactersCameraInterpSpeed(APrimalCharacter * ForBasedChar, const float DefaultTPVCameraSpeedInterpMultiplier, const float DefaultTPVOffsetInterpSpeed, float* TPVCameraSpeedInterpMultiplier, float* TPVOffsetInterpSpeed) { NativeCall<void, APrimalCharacter*, const float, const float, float*, float*>(this, "APrimalDinoCharacter.BP_OverrideBasedCharactersCameraInterpSpeed", ForBasedChar, DefaultTPVCameraSpeedInterpMultiplier, DefaultTPVOffsetInterpSpeed, TPVCameraSpeedInterpMultiplier, TPVOffsetInterpSpeed); }
    bool BP_OverrideCarriedCharacterTransform(APrimalCharacter * ForCarriedChar) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalDinoCharacter.BP_OverrideCarriedCharacterTransform", ForCarriedChar); }
    FString * BP_OverrideDinoName(FString * result, FString * CurrentDinoName, APlayerController * ForPC) { return NativeCall<FString*, FString*, FString*, APlayerController*>(this, "APrimalDinoCharacter.BP_OverrideDinoName", result, CurrentDinoName, ForPC); }
    FHitResult * BP_OverrideRiderCameraCollisionSweep(FHitResult * result, FVector * SweepStart, FVector * SweepEnd) { return NativeCall<FHitResult*, FHitResult*, FVector*, FVector*>(this, "APrimalDinoCharacter.BP_OverrideRiderCameraCollisionSweep", result, SweepStart, SweepEnd); }
    bool BP_PreventCarrying() { return NativeCall<bool>(this, "APrimalDinoCharacter.BP_PreventCarrying"); }
    bool BP_PreventCarryingByCharacter(APrimalCharacter * ByCarrier) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalDinoCharacter.BP_PreventCarryingByCharacter", ByCarrier); }
    bool BP_ShouldDisableBasedCharactersCameraInterpolation(APrimalCharacter * ForBasedChar) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalDinoCharacter.BP_ShouldDisableBasedCharactersCameraInterpolation", ForBasedChar); }
    int BPAdjustAttackIndex(int attackIndex) { return NativeCall<int, int>(this, "APrimalDinoCharacter.BPAdjustAttackIndex", attackIndex); }
    bool BPAllowCarryCharacter(APrimalCharacter * checkCharacter) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalDinoCharacter.BPAllowCarryCharacter", checkCharacter); }
    bool BPAllowClaiming(AShooterPlayerController * forPlayer) { return NativeCall<bool, AShooterPlayerController*>(this, "APrimalDinoCharacter.BPAllowClaiming", forPlayer); }
    bool BPAllowEquippingItemType(EPrimalEquipmentType::Type equipmentType) { return NativeCall<bool, EPrimalEquipmentType::Type>(this, "APrimalDinoCharacter.BPAllowEquippingItemType", equipmentType); }
    void BPBecomeAdult() { NativeCall<void>(this, "APrimalDinoCharacter.BPBecomeAdult"); }
    void BPBecomeBaby() { NativeCall<void>(this, "APrimalDinoCharacter.BPBecomeBaby"); }
    bool BPCanAutodrag(APrimalCharacter * characterToDrag) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalDinoCharacter.BPCanAutodrag", characterToDrag); }
    bool BPCanCryo(AShooterPlayerController * ForPC) { return NativeCall<bool, AShooterPlayerController*>(this, "APrimalDinoCharacter.BPCanCryo", ForPC); }
    bool BPCanDragCharacter(APrimalCharacter * Character) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalDinoCharacter.BPCanDragCharacter", Character); }
    bool BPCanIgnoreImmobilizationTrap(TSubclassOf<APrimalStructure> TrapClass, bool bForceTrigger) { return NativeCall<bool, TSubclassOf<APrimalStructure>, bool>(this, "APrimalDinoCharacter.BPCanIgnoreImmobilizationTrap", TrapClass, bForceTrigger); }
    bool BPCanMountOnCharacter(APrimalCharacter * character) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalDinoCharacter.BPCanMountOnCharacter", character); }
    bool BPCanTakePassenger(APrimalCharacter * Character, int PassengerSeatIndex, bool bForcePassenger, bool bAllowFlyersAndWaterDinos) { return NativeCall<bool, APrimalCharacter*, int, bool, bool>(this, "APrimalDinoCharacter.BPCanTakePassenger", Character, PassengerSeatIndex, bForcePassenger, bAllowFlyersAndWaterDinos); }
    bool BPCanTargetCorpse() { return NativeCall<bool>(this, "APrimalDinoCharacter.BPCanTargetCorpse"); }
    FVector * BPChargingModifyInputAcceleration(FVector * result, FVector inputAcceleration) { return NativeCall<FVector*, FVector*, FVector>(this, "APrimalDinoCharacter.BPChargingModifyInputAcceleration", result, inputAcceleration); }
    float BPClampMaxHarvestHealth() { return NativeCall<float>(this, "APrimalDinoCharacter.BPClampMaxHarvestHealth"); }
    bool BPDesiredRotationIsLocalSpace() { return NativeCall<bool>(this, "APrimalDinoCharacter.BPDesiredRotationIsLocalSpace"); }
    void BPDidClearCarriedCharacter(APrimalCharacter * PreviousCarriedCharacter) { NativeCall<void, APrimalCharacter*>(this, "APrimalDinoCharacter.BPDidClearCarriedCharacter", PreviousCarriedCharacter); }
    void BPDidSetCarriedCharacter(APrimalCharacter * PreviousCarriedCharacter) { NativeCall<void, APrimalCharacter*>(this, "APrimalDinoCharacter.BPDidSetCarriedCharacter", PreviousCarriedCharacter); }
    void BPDinoARKDownloadedBegin() { NativeCall<void>(this, "APrimalDinoCharacter.BPDinoARKDownloadedBegin"); }
    void BPDinoARKDownloadedEnd() { NativeCall<void>(this, "APrimalDinoCharacter.BPDinoARKDownloadedEnd"); }
    void BPDinoPostBeginPlay() { NativeCall<void>(this, "APrimalDinoCharacter.BPDinoPostBeginPlay"); }
    void BPDinoPrepareForARKUploading() { NativeCall<void>(this, "APrimalDinoCharacter.BPDinoPrepareForARKUploading"); }
    bool BPDinoTooltipCustomTamingProgressBar(bool* overrideTamingProgressBarIfActive, float* progressPercent, FString * Label) { return NativeCall<bool, bool*, float*, FString*>(this, "APrimalDinoCharacter.BPDinoTooltipCustomTamingProgressBar", overrideTamingProgressBarIfActive, progressPercent, Label); }
    bool BPDinoTooltipCustomTorpidityProgressBar(bool* overrideTorpidityProgressBarIfActive, float* progressPercent, FString * Label) { return NativeCall<bool, bool*, float*, FString*>(this, "APrimalDinoCharacter.BPDinoTooltipCustomTorpidityProgressBar", overrideTorpidityProgressBarIfActive, progressPercent, Label); }
    bool BPDisplayTamedMessage() { return NativeCall<bool>(this, "APrimalDinoCharacter.BPDisplayTamedMessage"); }
    void BPDoAttack(int AttackIndex) { NativeCall<void, int>(this, "APrimalDinoCharacter.BPDoAttack", AttackIndex); }
    void BPDoHarvestAttack(int harvestIndex) { NativeCall<void, int>(this, "APrimalDinoCharacter.BPDoHarvestAttack", harvestIndex); }
    void BPDrawToRiderHUD(AShooterHUD * HUD) { NativeCall<void, AShooterHUD*>(this, "APrimalDinoCharacter.BPDrawToRiderHUD", HUD); }
    void BPFedWakingTameEvent(APlayerController * ForPC) { NativeCall<void, APlayerController*>(this, "APrimalDinoCharacter.BPFedWakingTameEvent", ForPC); }
    bool BPForceTurretFastTargeting() { return NativeCall<bool>(this, "APrimalDinoCharacter.BPForceTurretFastTargeting"); }
    float BPGetCrosshairAlpha() { return NativeCall<float>(this, "APrimalDinoCharacter.BPGetCrosshairAlpha"); }
    FLinearColor * BPGetCrosshairColor(FLinearColor * result) { return NativeCall<FLinearColor*, FLinearColor*>(this, "APrimalDinoCharacter.BPGetCrosshairColor", result); }
    void BPGetCrosshairLocation(float CanvasClipX, float CanvasClipY, float* OutX, float* OutY) { NativeCall<void, float, float, float*, float*>(this, "APrimalDinoCharacter.BPGetCrosshairLocation", CanvasClipX, CanvasClipY, OutX, OutY); }
    FName * BPGetDragSocketDinoName(FName * result, APrimalDinoCharacter * aGrabbedDino) { return NativeCall<FName*, FName*, APrimalDinoCharacter*>(this, "APrimalDinoCharacter.BPGetDragSocketDinoName", result, aGrabbedDino); }
    FName * BPGetDragSocketName(FName * result, APrimalCharacter * DraggingChar) { return NativeCall<FName*, FName*, APrimalCharacter*>(this, "APrimalDinoCharacter.BPGetDragSocketName", result, DraggingChar); }
    FVector * BPGetHealthBarColor(FVector * result) { return NativeCall<FVector*, FVector*>(this, "APrimalDinoCharacter.BPGetHealthBarColor", result); }
    FName * BPGetLookOffsetSocketName(FName * result, APrimalCharacter * ForPrimalChar) { return NativeCall<FName*, FName*, APrimalCharacter*>(this, "APrimalDinoCharacter.BPGetLookOffsetSocketName", result, ForPrimalChar); }
    FName * BPGetRiderSocket(FName * result) { return NativeCall<FName*, FName*>(this, "APrimalDinoCharacter.BPGetRiderSocket", result); }
    FVector * BPGetRiderUnboardDirection(FVector * result, APrimalCharacter * RidingCharacter) { return NativeCall<FVector*, FVector*, APrimalCharacter*>(this, "APrimalDinoCharacter.BPGetRiderUnboardDirection", result, RidingCharacter); }
    FVector * BPGetRiderUnboardLocation(FVector * result, APrimalCharacter * RidingCharacter) { return NativeCall<FVector*, FVector*, APrimalCharacter*>(this, "APrimalDinoCharacter.BPGetRiderUnboardLocation", result, RidingCharacter); }
    bool BPHandleControllerInitiatedAttack(int AttackIndex) { return NativeCall<bool, int>(this, "APrimalDinoCharacter.BPHandleControllerInitiatedAttack", AttackIndex); }
    bool BPHandleOnStopFire() { return NativeCall<bool>(this, "APrimalDinoCharacter.BPHandleOnStopFire"); }
    bool BPHandleOnStopTargeting() { return NativeCall<bool>(this, "APrimalDinoCharacter.BPHandleOnStopTargeting"); }
    bool BPHandleUseButtonPress(AShooterPlayerController * RiderController) { return NativeCall<bool, AShooterPlayerController*>(this, "APrimalDinoCharacter.BPHandleUseButtonPress", RiderController); }
    bool BPIsBasedOnActor(AActor * Other) { return NativeCall<bool, AActor*>(this, "APrimalDinoCharacter.BPIsBasedOnActor", Other); }
    void BPKilledSomethingEvent(APrimalCharacter * killedTarget) { NativeCall<void, APrimalCharacter*>(this, "APrimalDinoCharacter.BPKilledSomethingEvent", killedTarget); }
    FRotator * BPModifyAimOffsetNoTarget(FRotator * result, FRotator * Aim) { return NativeCall<FRotator*, FRotator*, FRotator*>(this, "APrimalDinoCharacter.BPModifyAimOffsetNoTarget", result, Aim); }
    FVector * BPModifyAimOffsetTargetLocation(FVector * result, FVector * AimTargetLocation) { return NativeCall<FVector*, FVector*, FVector*>(this, "APrimalDinoCharacter.BPModifyAimOffsetTargetLocation", result, AimTargetLocation); }
    bool BPModifyDesiredRotation(FRotator * InDesiredRotation, FRotator * OutDesiredRotation) { return NativeCall<bool, FRotator*, FRotator*>(this, "APrimalDinoCharacter.BPModifyDesiredRotation", InDesiredRotation, OutDesiredRotation); }
    float BPModifyHarvestingQuantity(float originalQuantity, TSubclassOf<UPrimalItem> resourceSelected) { return NativeCall<float, float, TSubclassOf<UPrimalItem>>(this, "APrimalDinoCharacter.BPModifyHarvestingQuantity", originalQuantity, resourceSelected); }
    void BPModifyHarvestingWeightsArray(TArray<float> * resourceWeightsIn, TArray<UPrimalItem*> * resourceItems, TArray<float> * resourceWeightsOut) { NativeCall<void, TArray<float>*, TArray<UPrimalItem*>*, TArray<float>*>(this, "APrimalDinoCharacter.BPModifyHarvestingWeightsArray", resourceWeightsIn, resourceItems, resourceWeightsOut); }
    void BPNotifyAddPassenger(APrimalCharacter * PassengerChar, int SeatIndex) { NativeCall<void, APrimalCharacter*, int>(this, "APrimalDinoCharacter.BPNotifyAddPassenger", PassengerChar, SeatIndex); }
    void BPNotifyBabyAgeIncrement(float PreviousAge, float NewAge) { NativeCall<void, float, float>(this, "APrimalDinoCharacter.BPNotifyBabyAgeIncrement", PreviousAge, NewAge); }
    void BPNotifyCarriedDinoBabyAgeIncrement(APrimalDinoCharacter * AgingCarriedDino, float PreviousAge, float NewAge) { NativeCall<void, APrimalDinoCharacter*, float, float>(this, "APrimalDinoCharacter.BPNotifyCarriedDinoBabyAgeIncrement", AgingCarriedDino, PreviousAge, NewAge); }
    void BPNotifyClaimed() { NativeCall<void>(this, "APrimalDinoCharacter.BPNotifyClaimed"); }
    void BPNotifyClearPassenger(APrimalCharacter * PassengerChar, int SeatIndex) { NativeCall<void, APrimalCharacter*, int>(this, "APrimalDinoCharacter.BPNotifyClearPassenger", PassengerChar, SeatIndex); }
    void BPNotifyClearRider(AShooterCharacter * RiderClearing) { NativeCall<void, AShooterCharacter*>(this, "APrimalDinoCharacter.BPNotifyClearRider", RiderClearing); }
    void BPNotifyIfPassengerLaunchShoulderMount(APrimalCharacter * launchedCharacter) { NativeCall<void, APrimalCharacter*>(this, "APrimalDinoCharacter.BPNotifyIfPassengerLaunchShoulderMount", launchedCharacter); }
    void BPNotifyMateBoostChanged() { NativeCall<void>(this, "APrimalDinoCharacter.BPNotifyMateBoostChanged"); }
    void BPNotifySetRider(AShooterCharacter * RiderSetting) { NativeCall<void, AShooterCharacter*>(this, "APrimalDinoCharacter.BPNotifySetRider", RiderSetting); }
    void BPNotifyStructurePlacedNearby(APrimalStructure * NewStructure) { NativeCall<void, APrimalStructure*>(this, "APrimalDinoCharacter.BPNotifyStructurePlacedNearby", NewStructure); }
    void BPNotifyWildHarvestAttack(int harvestIndex) { NativeCall<void, int>(this, "APrimalDinoCharacter.BPNotifyWildHarvestAttack", harvestIndex); }
    void BPOnClearMountedDino() { NativeCall<void>(this, "APrimalDinoCharacter.BPOnClearMountedDino"); }
    void BPOnDinoCheat(FName CheatName, bool bSetValue, float Value) { NativeCall<void, FName, bool, float>(this, "APrimalDinoCharacter.BPOnDinoCheat", CheatName, bSetValue, Value); }
    void BPOnDinoStartled(UAnimMontage * StartledAnimPlayed, bool bFromAIController) { NativeCall<void, UAnimMontage*, bool>(this, "APrimalDinoCharacter.BPOnDinoStartled", StartledAnimPlayed, bFromAIController); }
    void BPOnEndCharging() { NativeCall<void>(this, "APrimalDinoCharacter.BPOnEndCharging"); }
    void BPOnRefreshColorization(TArray<FLinearColor> * Colors) { NativeCall<void, TArray<FLinearColor>*>(this, "APrimalDinoCharacter.BPOnRefreshColorization", Colors); }
    void BPOnRepIsCharging() { NativeCall<void>(this, "APrimalDinoCharacter.BPOnRepIsCharging"); }
    void BPOnSetFlight(bool bFly) { NativeCall<void, bool>(this, "APrimalDinoCharacter.BPOnSetFlight", bFly); }
    void BPOnSetMountedDino() { NativeCall<void>(this, "APrimalDinoCharacter.BPOnSetMountedDino"); }
    bool BPOnStartJump() { return NativeCall<bool>(this, "APrimalDinoCharacter.BPOnStartJump"); }
    bool BPOnStopJump() { return NativeCall<bool>(this, "APrimalDinoCharacter.BPOnStopJump"); }
    void BPOnTamedProcessOrder(APrimalCharacter * FromCharacter, EDinoTamedOrder::Type OrderType, bool bForce, AActor * enemyTarget, bool orderNotExecuted) { NativeCall<void, APrimalCharacter*, EDinoTamedOrder::Type, bool, AActor*, bool>(this, "APrimalDinoCharacter.BPOnTamedProcessOrder", FromCharacter, OrderType, bForce, enemyTarget, orderNotExecuted); }
    void BPOrderedMoveToLoc(FVector * DestLoc) { NativeCall<void, FVector*>(this, "APrimalDinoCharacter.BPOrderedMoveToLoc", DestLoc); }
    FVector * BPOverrideFloatingHUDLocation(FVector * result) { return NativeCall<FVector*, FVector*>(this, "APrimalDinoCharacter.BPOverrideFloatingHUDLocation", result); }
    int BPOverrideGetAttackAnimationIndex(int AttackIndex, TArray<UAnimMontage*> * AnimationArray) { return NativeCall<int, int, TArray<UAnimMontage*>*>(this, "APrimalDinoCharacter.BPOverrideGetAttackAnimationIndex", AttackIndex, AnimationArray); }
    float BPOverrideHealthBarOffset(APlayerController * forPC) { return NativeCall<float, APlayerController*>(this, "APrimalDinoCharacter.BPOverrideHealthBarOffset", forPC); }
    bool BPOverrideMoveToOrder(FVector MoveToLocation, AShooterCharacter * OrderingPlayer) { return NativeCall<bool, FVector, AShooterCharacter*>(this, "APrimalDinoCharacter.BPOverrideMoveToOrder", MoveToLocation, OrderingPlayer); }
    FString * BPOverrideTamingDescriptionLabel(FString * result, FSlateColor * TextColor) { return NativeCall<FString*, FString*, FSlateColor*>(this, "APrimalDinoCharacter.BPOverrideTamingDescriptionLabel", result, TextColor); }
    bool BPPreventOrderAllowed(APrimalCharacter * FromCharacter, EDinoTamedOrder::Type OrderType, bool bForce, AActor * enemyTarget, bool orderNotExecuted) { return NativeCall<bool, APrimalCharacter*, EDinoTamedOrder::Type, bool, AActor*, bool>(this, "APrimalDinoCharacter.BPPreventOrderAllowed", FromCharacter, OrderType, bForce, enemyTarget, orderNotExecuted); }
    bool BPPreventRiding(AShooterCharacter * byPawn, bool bDontCheckDistance) { return NativeCall<bool, AShooterCharacter*, bool>(this, "APrimalDinoCharacter.BPPreventRiding", byPawn, bDontCheckDistance); }
    void BPSentKilledNotification(AShooterPlayerController * ToPC) { NativeCall<void, AShooterPlayerController*>(this, "APrimalDinoCharacter.BPSentKilledNotification", ToPC); }
    void BPSetupTamed(bool bWasJustTamed) { NativeCall<void, bool>(this, "APrimalDinoCharacter.BPSetupTamed", bWasJustTamed); }
    bool BPShouldCancelDoAttack(int AttackIndex) { return NativeCall<bool, int>(this, "APrimalDinoCharacter.BPShouldCancelDoAttack", AttackIndex); }
    bool BPShouldForceFlee() { return NativeCall<bool>(this, "APrimalDinoCharacter.BPShouldForceFlee"); }
    bool BPShowTamingPanel(bool currentVisibility) { return NativeCall<bool, bool>(this, "APrimalDinoCharacter.BPShowTamingPanel", currentVisibility); }
    void BPTamedConsumeFoodItem(UPrimalItem * foodItem) { NativeCall<void, UPrimalItem*>(this, "APrimalDinoCharacter.BPTamedConsumeFoodItem", foodItem); }
    void BPUnsetupDinoTameable() { NativeCall<void>(this, "APrimalDinoCharacter.BPUnsetupDinoTameable"); }
    float BPUnstasisConsumeFood(float FoodNeeded) { return NativeCall<float, float>(this, "APrimalDinoCharacter.BPUnstasisConsumeFood", FoodNeeded); }
    void BPUntamedConsumeFoodItem(UPrimalItem * foodItem) { NativeCall<void, UPrimalItem*>(this, "APrimalDinoCharacter.BPUntamedConsumeFoodItem", foodItem); }
    void BSetupDinoTameable() { NativeCall<void>(this, "APrimalDinoCharacter.BSetupDinoTameable"); }
    void ClientInterruptLanding() { NativeCall<void>(this, "APrimalDinoCharacter.ClientInterruptLanding"); }
    void ClientShouldNotifyLanded() { NativeCall<void>(this, "APrimalDinoCharacter.ClientShouldNotifyLanded"); }
    void ClientStartLanding(FVector landingLoc) { NativeCall<void, FVector>(this, "APrimalDinoCharacter.ClientStartLanding", landingLoc); }
    void DinoFireProjectileEx(TSubclassOf<AShooterProjectile> ProjectileClass, FVector Origin, FVector_NetQuantizeNormal ShootDir, bool bScaleProjDamageByDinoDamage, bool bAddDinoVelocityToProjectile, float OverrideInitialSpeed, float OverrideMaxSpeed, float ExtraDirectDamageMultiplier, float ExtraExplosionDamageMultiplier, bool spawnOnOwningClient) { NativeCall<void, TSubclassOf<AShooterProjectile>, FVector, FVector_NetQuantizeNormal, bool, bool, float, float, float, float, bool>(this, "APrimalDinoCharacter.DinoFireProjectileEx", ProjectileClass, Origin, ShootDir, bScaleProjDamageByDinoDamage, bAddDinoVelocityToProjectile, OverrideInitialSpeed, OverrideMaxSpeed, ExtraDirectDamageMultiplier, ExtraExplosionDamageMultiplier, spawnOnOwningClient); }
    void DinoShoulderMountedLaunch(FVector launchDir, AShooterCharacter * throwingCharacter) { NativeCall<void, FVector, AShooterCharacter*>(this, "APrimalDinoCharacter.DinoShoulderMountedLaunch", launchDir, throwingCharacter); }
    void DoNeuter() { NativeCall<void>(this, "APrimalDinoCharacter.DoNeuter"); }
    float DoOverrideMountedAirControl(float AirControlIn) { return NativeCall<float, float>(this, "APrimalDinoCharacter.DoOverrideMountedAirControl", AirControlIn); }
    void FedWakingTameDino() { NativeCall<void>(this, "APrimalDinoCharacter.FedWakingTameDino"); }
    void FireMultipleProjectiles(TArray<FVector> * Locations, TArray<FVector> * Directions, bool bScaleProjectileDamageByDinoDamage) { NativeCall<void, TArray<FVector>*, TArray<FVector>*, bool>(this, "APrimalDinoCharacter.FireMultipleProjectiles", Locations, Directions, bScaleProjectileDamageByDinoDamage); }
    void FireProjectile(FVector Origin, FVector_NetQuantizeNormal ShootDir, bool bScaleProjDamageByDinoDamage) { NativeCall<void, FVector, FVector_NetQuantizeNormal, bool>(this, "APrimalDinoCharacter.FireProjectile", Origin, ShootDir, bScaleProjDamageByDinoDamage); }
    void ForceUpdateColorSets(int ColorRegion, int ColorSet) { NativeCall<void, int, int>(this, "APrimalDinoCharacter.ForceUpdateColorSets", ColorRegion, ColorSet); }
    UAnimMontage * GetDinoLevelUpAnimation() { return NativeCall<UAnimMontage*>(this, "APrimalDinoCharacter.GetDinoLevelUpAnimation"); }
    USoundBase * GetDinoTameSound() { return NativeCall<USoundBase*>(this, "APrimalDinoCharacter.GetDinoTameSound"); }
    FName * GetSocketForMeleeTraceForHitBlockers(FName * result, int AttackIndex) { return NativeCall<FName*, FName*, int>(this, "APrimalDinoCharacter.GetSocketForMeleeTraceForHitBlockers", result, AttackIndex); }
    void HandleMountedDinoAction(AShooterPlayerController * PC) { NativeCall<void, AShooterPlayerController*>(this, "APrimalDinoCharacter.HandleMountedDinoAction", PC); }
    bool InterceptMountedOnPlayerEmoteAnim(UAnimMontage * EmoteAnim) { return NativeCall<bool, UAnimMontage*>(this, "APrimalDinoCharacter.InterceptMountedOnPlayerEmoteAnim", EmoteAnim); }
    bool InterceptRiderEmoteAnim(UAnimMontage * EmoteAnim) { return NativeCall<bool, UAnimMontage*>(this, "APrimalDinoCharacter.InterceptRiderEmoteAnim", EmoteAnim); }
    void InterruptLatching() { NativeCall<void>(this, "APrimalDinoCharacter.InterruptLatching"); }
    void NetUpdateDinoNameStrings(FString * NewTamerString, FString * NewTamedName) { NativeCall<void, FString*, FString*>(this, "APrimalDinoCharacter.NetUpdateDinoNameStrings", NewTamerString, NewTamedName); }
    void NetUpdateDinoOwnerData(FString * NewOwningPlayerName, int NewOwningPlayerID) { NativeCall<void, FString*, int>(this, "APrimalDinoCharacter.NetUpdateDinoOwnerData", NewOwningPlayerName, NewOwningPlayerID); }
    void OnUpdateMountedDinoMeshHiding(bool bshouldBeVisible) { NativeCall<void, bool>(this, "APrimalDinoCharacter.OnUpdateMountedDinoMeshHiding", bshouldBeVisible); }
    bool OverrideFinalWanderLocation(FVector * outVec) { return NativeCall<bool, FVector*>(this, "APrimalDinoCharacter.OverrideFinalWanderLocation", outVec); }
    void OverrideRandomWanderLocation(FVector * originalDestination, FVector * inVec) { NativeCall<void, FVector*, FVector*>(this, "APrimalDinoCharacter.OverrideRandomWanderLocation", originalDestination, inVec); }
    void PlayHardEndChargingShake() { NativeCall<void>(this, "APrimalDinoCharacter.PlayHardEndChargingShake"); }
    void RidingTick(float DeltaSeconds) { NativeCall<void, float>(this, "APrimalDinoCharacter.RidingTick", DeltaSeconds); }
    void ServerClearRider(int OverrideUnboardDirection) { NativeCall<void, int>(this, "APrimalDinoCharacter.ServerClearRider", OverrideUnboardDirection); }
    void ServerFinishedLanding() { NativeCall<void>(this, "APrimalDinoCharacter.ServerFinishedLanding"); }
    void ServerInterruptLanding() { NativeCall<void>(this, "APrimalDinoCharacter.ServerInterruptLanding"); }
    void ServerRequestAttack(int attackIndex) { NativeCall<void, int>(this, "APrimalDinoCharacter.ServerRequestAttack", attackIndex); }
    void ServerRequestBraking(bool bWantsToBrake) { NativeCall<void, bool>(this, "APrimalDinoCharacter.ServerRequestBraking", bWantsToBrake); }
    void ServerRequestToggleFlight() { NativeCall<void>(this, "APrimalDinoCharacter.ServerRequestToggleFlight"); }
    void ServerRequestWaterSurfaceJump() { NativeCall<void>(this, "APrimalDinoCharacter.ServerRequestWaterSurfaceJump"); }
    void ServerSetRiderMountedWeaponRotation(FRotator InVal) { NativeCall<void, FRotator>(this, "APrimalDinoCharacter.ServerSetRiderMountedWeaponRotation", InVal); }
    void ServerToClientsPlayAttackAnimation(char AttackinfoIndex, char animationIndex, float InPlayRate, FName StartSectionName, bool bForceTickPoseAndServerUpdateMesh, bool bForceTickPoseOnServer, AActor * MyTarget) { NativeCall<void, char, char, float, FName, bool, bool, AActor*>(this, "APrimalDinoCharacter.ServerToClientsPlayAttackAnimation", AttackinfoIndex, animationIndex, InPlayRate, StartSectionName, bForceTickPoseAndServerUpdateMesh, bForceTickPoseOnServer, MyTarget); }
    void ServerToggleCharging() { NativeCall<void>(this, "APrimalDinoCharacter.ServerToggleCharging"); }
    void ServerUpdateAttackTargets(AActor * AttackTarget, FVector AttackLocation) { NativeCall<void, AActor*, FVector>(this, "APrimalDinoCharacter.ServerUpdateAttackTargets", AttackTarget, AttackLocation); }
    bool SetTurretMode(bool enabled) { return NativeCall<bool, bool>(this, "APrimalDinoCharacter.SetTurretMode", enabled); }
    void UpdateBabyCuddling(long double NewBabyNextCuddleTime, char NewBabyCuddleType, TSubclassOf<UPrimalItem> NewBabyCuddleFood) { NativeCall<void, long double, char, TSubclassOf<UPrimalItem>>(this, "APrimalDinoCharacter.UpdateBabyCuddling", NewBabyNextCuddleTime, NewBabyCuddleType, NewBabyCuddleFood); }
    void UpdateImprintingDetails(FString * NewImprinterName, unsigned __int64 NewImprinterPlayerDataID) { NativeCall<void, FString*, unsigned __int64>(this, "APrimalDinoCharacter.UpdateImprintingDetails", NewImprinterName, NewImprinterPlayerDataID); }
    void UpdateImprintingQuality(float NewImprintingQuality) { NativeCall<void, float>(this, "APrimalDinoCharacter.UpdateImprintingQuality", NewImprintingQuality); }
    void UpdateTribeGroupRanks(char NewTribeGroupPetOrderingRank, char NewTribeGroupPetRidingRank) { NativeCall<void, char, char>(this, "APrimalDinoCharacter.UpdateTribeGroupRanks", NewTribeGroupPetOrderingRank, NewTribeGroupPetRidingRank); }
    void GetDinoData(FARKDinoData * OutDinoData) { NativeCall<void, FARKDinoData *>(this, "APrimalDinoCharacter.GetDinoData", OutDinoData); }
    FString* GetColorSetInidcesAsString(FString* result) { return NativeCall<FString*, FString*>(this, "APrimalDinoCharacter.GetColorSetInidcesAsString", result); }
    TArray<FName>* GetColorSetNamesAsArray(TArray<FName>* result) { return NativeCall<TArray<FName>*, TArray<FName>*>(this, "APrimalDinoCharacter.GetColorSetNamesAsArray", result); }
    static APrimalDinoCharacter* SpawnFromDinoDataEx(FARKDinoData* InDinoData, UWorld* InWorld, FVector* AtLocation, FRotator* AtRotation, bool* dupedDino, int ForTeam, bool bGenerateNewDinoID, AShooterPlayerController* TamerController, bool beginPlay) { return NativeCall<APrimalDinoCharacter*, FARKDinoData*, UWorld*, FVector*, FRotator*, bool*, int, bool, AShooterPlayerController*, bool>(nullptr, "APrimalDinoCharacter.SpawnFromDinoDataEx", InDinoData, InWorld, AtLocation, AtRotation, dupedDino, ForTeam, bGenerateNewDinoID, TamerController, beginPlay); }
};
 
struct AShooterWeapon : AActor
{
    float& EquipTimeField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.EquipTime"); }
    UAnimMontage* OverrideProneInAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterWeapon.OverrideProneInAnim"); }
    UAnimMontage* OverrideProneOutAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterWeapon.OverrideProneOutAnim"); }
    UAnimMontage* OverrideJumpAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterWeapon.OverrideJumpAnim"); }
    UAnimMontage* OverrideLandedAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterWeapon.OverrideLandedAnim"); }
    TArray<UAnimSequence*> OverrideRiderAnimSequenceFromField() { return *GetNativePointerField<TArray<UAnimSequence*>*>(this, "AShooterWeapon.OverrideRiderAnimSequenceFrom"); }
    TArray<UAnimSequence*> OverrideRiderAnimSequenceToField() { return *GetNativePointerField<TArray<UAnimSequence*>*>(this, "AShooterWeapon.OverrideRiderAnimSequenceTo"); }
    float& ItemDurabilityToConsumePerMeleeHitField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.ItemDurabilityToConsumePerMeleeHit"); }
    float& AmmoIconsCountField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.AmmoIconsCount"); }
    float& TargetingTooltipCheckRangeField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.TargetingTooltipCheckRange"); }
    int& PrimaryClipIconOffsetField() { return *GetNativePointerField<int*>(this, "AShooterWeapon.PrimaryClipIconOffset"); }
    int& SecondaryClipIconOffsetField() { return *GetNativePointerField<int*>(this, "AShooterWeapon.SecondaryClipIconOffset"); }
    FVector2D& TargetingInfoTooltipPaddingField() { return *GetNativePointerField<FVector2D*>(this, "AShooterWeapon.TargetingInfoTooltipPadding"); }
    FVector2D& TargetingInfoTooltipScaleField() { return *GetNativePointerField<FVector2D*>(this, "AShooterWeapon.TargetingInfoTooltipScale"); }
    bool& bOnlyPassiveDurabilityWhenAccessoryActiveField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bOnlyPassiveDurabilityWhenAccessoryActive"); }
    bool& bDisableShooterOnElectricStormField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bDisableShooterOnElectricStorm"); }
    FName& OverrideAttachPointField() { return *GetNativePointerField<FName*>(this, "AShooterWeapon.OverrideAttachPoint"); }
    FVector& FPVRelativeLocationField() { return *GetNativePointerField<FVector*>(this, "AShooterWeapon.FPVRelativeLocation"); }
    FRotator& FPVRelativeRotationField() { return *GetNativePointerField<FRotator*>(this, "AShooterWeapon.FPVRelativeRotation"); }
    FVector& FPVRelativeLocation_TargetingField() { return *GetNativePointerField<FVector*>(this, "AShooterWeapon.FPVRelativeLocation_Targeting"); }
    FRotator& FPVRelativeRotation_TargetingField() { return *GetNativePointerField<FRotator*>(this, "AShooterWeapon.FPVRelativeRotation_Targeting"); }
    float& FPVEnterTargetingInterpSpeedField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.FPVEnterTargetingInterpSpeed"); }
    float& FPVExitTargetingInterpSpeedField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.FPVExitTargetingInterpSpeed"); }
    float& EndDoMeleeSwingTimeField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.EndDoMeleeSwingTime"); }
    FRotator& FPVLookAtMaximumOffsetField() { return *GetNativePointerField<FRotator*>(this, "AShooterWeapon.FPVLookAtMaximumOffset"); }
    FRotator& FPVLookAtSpeedBaseField() { return *GetNativePointerField<FRotator*>(this, "AShooterWeapon.FPVLookAtSpeedBase"); }
    FRotator& FPVLookAtInterpSpeedField() { return *GetNativePointerField<FRotator*>(this, "AShooterWeapon.FPVLookAtInterpSpeed"); }
    FRotator& FPVLookAtMaximumOffset_TargetingField() { return *GetNativePointerField<FRotator*>(this, "AShooterWeapon.FPVLookAtMaximumOffset_Targeting"); }
    FRotator& FPVLookAtSpeedBase_TargetingField() { return *GetNativePointerField<FRotator*>(this, "AShooterWeapon.FPVLookAtSpeedBase_Targeting"); }
    FRotator& FPVLookAtInterpSpeed_TargetingField() { return *GetNativePointerField<FRotator*>(this, "AShooterWeapon.FPVLookAtInterpSpeed_Targeting"); }
    FVector& FPVImmobilizedLocationOffsetField() { return *GetNativePointerField<FVector*>(this, "AShooterWeapon.FPVImmobilizedLocationOffset"); }
    FRotator& FPVImmobilizedRotationOffsetField() { return *GetNativePointerField<FRotator*>(this, "AShooterWeapon.FPVImmobilizedRotationOffset"); }
    float& FPVImmobilizedInterpSpeedField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.FPVImmobilizedInterpSpeed"); }
    bool& bUseBlueprintAnimNotificationsField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bUseBlueprintAnimNotifications"); }
    TArray<FName>& MeleeSwingSocketsField() { return *GetNativePointerField<TArray<FName>*>(this, "AShooterWeapon.MeleeSwingSockets"); }
    float& AllowMeleeTimeBeforeAnimationEndField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.AllowMeleeTimeBeforeAnimationEnd"); }
    UPrimalItem* AssociatedPrimalItemField() { return *GetNativePointerField<UPrimalItem**>(this, "AShooterWeapon.AssociatedPrimalItem"); }
    AMissionType* AssociatedMissionField() { return *GetNativePointerField<AMissionType**>(this, "AShooterWeapon.AssociatedMission"); }
    bool& bCanBeUsedAsEquipmentField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bCanBeUsedAsEquipment"); }
    FItemNetInfo& AssociatedItemNetInfoField() { return *GetNativePointerField<FItemNetInfo*>(this, "AShooterWeapon.AssociatedItemNetInfo"); }
    FWeaponData& WeaponConfigField() { return *GetNativePointerField<FWeaponData*>(this, "AShooterWeapon.WeaponConfig"); }
    TSubclassOf<UPrimalItem>& WeaponAmmoItemTemplateField() { return *GetNativePointerField<TSubclassOf<UPrimalItem>*>(this, "AShooterWeapon.WeaponAmmoItemTemplate"); }
    long double& NextAllowedMeleeTimeField() { return *GetNativePointerField<long double*>(this, "AShooterWeapon.NextAllowedMeleeTime"); }
    TArray<FVector>& LastSocketPositionsField() { return *GetNativePointerField<TArray<FVector>*>(this, "AShooterWeapon.LastSocketPositions"); }
    TArray<AActor*> MeleeSwingHurtListField() { return *GetNativePointerField<TArray<AActor*>*>(this, "AShooterWeapon.MeleeSwingHurtList"); }
    long double& LastFPVRenderTimeField() { return *GetNativePointerField<long double*>(this, "AShooterWeapon.LastFPVRenderTime"); }
    FRotator& LastCameraRotationField() { return *GetNativePointerField<FRotator*>(this, "AShooterWeapon.LastCameraRotation"); }
    FRotator& FPVAdditionalLookRotOffsetField() { return *GetNativePointerField<FRotator*>(this, "AShooterWeapon.FPVAdditionalLookRotOffset"); }
    FVector& FPVLastLocOffsetField() { return *GetNativePointerField<FVector*>(this, "AShooterWeapon.FPVLastLocOffset"); }
    FVector& FPVLastVROffsetField() { return *GetNativePointerField<FVector*>(this, "AShooterWeapon.FPVLastVROffset"); }
    FVector& FPVRelativeLocationOffscreenOffsetField() { return *GetNativePointerField<FVector*>(this, "AShooterWeapon.FPVRelativeLocationOffscreenOffset"); }
    FRotator& FPVLastRotOffsetField() { return *GetNativePointerField<FRotator*>(this, "AShooterWeapon.FPVLastRotOffset"); }
    AShooterCharacter* MyPawnField() { return *GetNativePointerField<AShooterCharacter**>(this, "AShooterWeapon.MyPawn"); }
    UAudioComponent* FireACField() { return *GetNativePointerField<UAudioComponent**>(this, "AShooterWeapon.FireAC"); }
    FName& MuzzleAttachPointField() { return *GetNativePointerField<FName*>(this, "AShooterWeapon.MuzzleAttachPoint"); }
    USoundCue* FireSoundField() { return *GetNativePointerField<USoundCue**>(this, "AShooterWeapon.FireSound"); }
    USoundCue* AltFireSoundField() { return *GetNativePointerField<USoundCue**>(this, "AShooterWeapon.AltFireSound"); }
    USoundCue* FireFinishSoundField() { return *GetNativePointerField<USoundCue**>(this, "AShooterWeapon.FireFinishSound"); }
    USoundCue* OutOfAmmoSoundField() { return *GetNativePointerField<USoundCue**>(this, "AShooterWeapon.OutOfAmmoSound"); }
    int& MeleeDamageAmountField() { return *GetNativePointerField<int*>(this, "AShooterWeapon.MeleeDamageAmount"); }
    float& TheMeleeSwingRadiusField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.TheMeleeSwingRadius"); }
    float& MeleeDamageImpulseField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.MeleeDamageImpulse"); }
    UAnimMontage* WeaponMesh3PReloadAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterWeapon.WeaponMesh3PReloadAnim"); }
    USoundCue* EquipSoundField() { return *GetNativePointerField<USoundCue**>(this, "AShooterWeapon.EquipSound"); }
    UAnimMontage* WeaponMesh3PFireAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterWeapon.WeaponMesh3PFireAnim"); }
    float& FPVMoveOffscreenWhenTurningMaxMoveWeaponSpeedField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.FPVMoveOffscreenWhenTurningMaxMoveWeaponSpeed"); }
    float& FPVMoveOffscreenWhenTurningMinMoveWeaponSpeedField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.FPVMoveOffscreenWhenTurningMinMoveWeaponSpeed"); }
    float& FPVMoveOffscreenWhenTurningMinViewRotSpeedField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.FPVMoveOffscreenWhenTurningMinViewRotSpeed"); }
    float& FPVMoveOffscreenWhenTurningMaxViewRotSpeedField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.FPVMoveOffscreenWhenTurningMaxViewRotSpeed"); }
    float& FPVMoveOffscreenIdleRestoreIntervalField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.FPVMoveOffscreenIdleRestoreInterval"); }
    float& FPVMoveOffscreenIdleRestoreSpeedField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.FPVMoveOffscreenIdleRestoreSpeed"); }
    float& FPVMoveOffscreenWhenTurningMaxOffsetField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.FPVMoveOffscreenWhenTurningMaxOffset"); }
    long double& FPVStoppedTurningTimeField() { return *GetNativePointerField<long double*>(this, "AShooterWeapon.FPVStoppedTurningTime"); }
    float& ItemDestructionUnequipWeaponDelayField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.ItemDestructionUnequipWeaponDelay"); }
    float& WeaponUnequipDelayField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.WeaponUnequipDelay"); }
    EWeaponState::Type& CurrentStateField() { return *GetNativePointerField<EWeaponState::Type*>(this, "AShooterWeapon.CurrentState"); }
    long double& LastFireTimeField() { return *GetNativePointerField<long double*>(this, "AShooterWeapon.LastFireTime"); }
    int& CurrentAmmoField() { return *GetNativePointerField<int*>(this, "AShooterWeapon.CurrentAmmo"); }
    int& CurrentAmmoInClipField() { return *GetNativePointerField<int*>(this, "AShooterWeapon.CurrentAmmoInClip"); }
    bool& bReplicateCurrentAmmoInClipToNonOwnersField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bReplicateCurrentAmmoInClipToNonOwners"); }
    bool& bUseBPAdjustAmmoPerShotField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bUseBPAdjustAmmoPerShot"); }
    FName& FPVAccessoryToggleComponentField() { return *GetNativePointerField<FName*>(this, "AShooterWeapon.FPVAccessoryToggleComponent"); }
    FName& TPVAccessoryToggleComponentField() { return *GetNativePointerField<FName*>(this, "AShooterWeapon.TPVAccessoryToggleComponent"); }
    float& TimeToAutoReloadField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.TimeToAutoReload"); }
    USoundBase* ToggleAccessorySoundField() { return *GetNativePointerField<USoundBase**>(this, "AShooterWeapon.ToggleAccessorySound"); }
    int& FiredLastNoAmmoShotField() { return *GetNativePointerField<int*>(this, "AShooterWeapon.FiredLastNoAmmoShot"); }
    long double& LastNotifyShotTimeField() { return *GetNativePointerField<long double*>(this, "AShooterWeapon.LastNotifyShotTime"); }
    TSubclassOf<UDamageType>& MeleeDamageTypeField() { return *GetNativePointerField<TSubclassOf<UDamageType>*>(this, "AShooterWeapon.MeleeDamageType"); }
    FVector& VRTargetingModelOffsetField() { return *GetNativePointerField<FVector*>(this, "AShooterWeapon.VRTargetingModelOffset"); }
    FVector& VRTargetingAimOriginOffsetField() { return *GetNativePointerField<FVector*>(this, "AShooterWeapon.VRTargetingAimOriginOffset"); }
    UMaterialInterface* ScopeOverlayMIField() { return *GetNativePointerField<UMaterialInterface**>(this, "AShooterWeapon.ScopeOverlayMI"); }
    UMaterialInterface* ScopeCrosshairMIField() { return *GetNativePointerField<UMaterialInterface**>(this, "AShooterWeapon.ScopeCrosshairMI"); }
    float& ScopeCrosshairSizeField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.ScopeCrosshairSize"); }
    FName& ScopeCrosshairColorParameterField() { return *GetNativePointerField<FName*>(this, "AShooterWeapon.ScopeCrosshairColorParameter"); }
    float& MinItemDurabilityPercentageForShotField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.MinItemDurabilityPercentageForShot"); }
    float& OverrideTargetingFOVField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.OverrideTargetingFOV"); }
    float& TargetingDelayTimeField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.TargetingDelayTime"); }
    float& TargetingFOVInterpSpeedField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.TargetingFOVInterpSpeed"); }
    float& AimDriftYawAngleField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.AimDriftYawAngle"); }
    float& AimDriftPitchAngleField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.AimDriftPitchAngle"); }
    float& AimDriftYawFrequencyField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.AimDriftYawFrequency"); }
    float& AimDriftPitchFrequencyField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.AimDriftPitchFrequency"); }
    UAnimMontage* AlternateInventoryEquipAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterWeapon.AlternateInventoryEquipAnim"); }
    float& MeleeHitRandomChanceToDestroyItemField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.MeleeHitRandomChanceToDestroyItem"); }
    float& GlobalFireCameraShakeScaleField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.GlobalFireCameraShakeScale"); }
    float& DurabilityCostToEquipField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.DurabilityCostToEquip"); }
    float& PassiveDurabilityCostPerIntervalField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.PassiveDurabilityCostPerInterval"); }
    float& PassiveDurabilityCostIntervalField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.PassiveDurabilityCostInterval"); }
    float& GlobalFireCameraShakeScaleTargetingField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.GlobalFireCameraShakeScaleTargeting"); }
    float& MeleeCameraShakeSpeedScaleField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.MeleeCameraShakeSpeedScale"); }
    float& ReloadCameraShakeSpeedScaleField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.ReloadCameraShakeSpeedScale"); }
    float& MeleeConsumesStaminaField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.MeleeConsumesStamina"); }
    float& HypoThermiaInsulationField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.HypoThermiaInsulation"); }
    float& HyperThermiaInsulationField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.HyperThermiaInsulation"); }
    float& InsulationRangeField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.InsulationRange"); }
    long double& LastDurabilityConsumptionTimeField() { return *GetNativePointerField<long double*>(this, "AShooterWeapon.LastDurabilityConsumptionTime"); }
    bool& bLastMeleeHitField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bLastMeleeHit"); }
    bool& bLastMeleeHitStationaryField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bLastMeleeHitStationary"); }
    bool& bClientAlreadyReloadedField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bClientAlreadyReloaded"); }
    float& AutoReloadTimerField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.AutoReloadTimer"); }
    bool& bConsumedDurabilityForThisMeleeHitField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bConsumedDurabilityForThisMeleeHit"); }
    USoundCue* TargetingSoundField() { return *GetNativePointerField<USoundCue**>(this, "AShooterWeapon.TargetingSound"); }
    USoundCue* UntargetingSoundField() { return *GetNativePointerField<USoundCue**>(this, "AShooterWeapon.UntargetingSound"); }
    float& FPVMeleeTraceFXRangeField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.FPVMeleeTraceFXRange"); }
    TSubclassOf<UShooterDamageType>& MeleeAttackUsableHarvestDamageTypeField() { return *GetNativePointerField<TSubclassOf<UShooterDamageType>*>(this, "AShooterWeapon.MeleeAttackUsableHarvestDamageType"); }
    float& MeleeAttackHarvetUsableComponentsRadiusField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.MeleeAttackHarvetUsableComponentsRadius"); }
    float& MeleeAttackUsableHarvestDamageMultiplierField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.MeleeAttackUsableHarvestDamageMultiplier"); }
    FieldArray<bool, 6> bColorizeRegionsField() { return { this, "AShooterWeapon.bColorizeRegions" }; }
    UAnimMontage* TPVForcePlayAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterWeapon.TPVForcePlayAnim"); }
    bool& bPreventOpeningInventoryField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bPreventOpeningInventory"); }
    bool& bAllowUseOnSeatingStructureField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bAllowUseOnSeatingStructure"); }
    bool& bOnlyUseOnSeatingStructureField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bOnlyUseOnSeatingStructure"); }
    bool& bBPDoClientCheckCanFireField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bBPDoClientCheckCanFire"); }
    bool& bRestrictTPVCameraYawField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bRestrictTPVCameraYaw"); }
    float& TPVCameraYawRangeField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.TPVCameraYawRange"); }
    bool& bFoceSimulatedTickField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bFoceSimulatedTick"); }
    bool& bWasLastFireFromGamePadField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bWasLastFireFromGamePad"); }
    bool& bDisableWeaponCrosshairField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bDisableWeaponCrosshair"); }
    UStaticMesh* DyePreviewMeshOverrideSMField() { return *GetNativePointerField<UStaticMesh**>(this, "AShooterWeapon.DyePreviewMeshOverrideSM"); }
    bool& bBPOverrideAspectRatioField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bBPOverrideAspectRatio"); }
    bool& bBPOverrideFPVMasterPoseComponentField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bBPOverrideFPVMasterPoseComponent"); }
    bool& bForceAllowMountedWeaponryField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bForceAllowMountedWeaponry"); }
    float& FireCameraShakeSpreadScaleExponentField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.FireCameraShakeSpreadScaleExponent"); }
    float& FireCameraShakeSpreadScaleExponentLessThanField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.FireCameraShakeSpreadScaleExponentLessThan"); }
    float& FireCameraShakeSpreadScaleMultiplierLessThanField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.FireCameraShakeSpreadScaleMultiplierLessThan"); }
    float& FireCameraShakeSpreadScaleMultiplierField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.FireCameraShakeSpreadScaleMultiplier"); }
    bool& bUseFireCameraShakeScaleField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bUseFireCameraShakeScale"); }
    bool& bForceTickWithNoControllerField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bForceTickWithNoController"); }
    FInstantWeaponData& InstantConfigField() { return *GetNativePointerField<FInstantWeaponData*>(this, "AShooterWeapon.InstantConfig"); }
    float& CurrentFiringSpreadField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.CurrentFiringSpread"); }
    TSubclassOf<APrimalBuff>& ScopedBuffField() { return *GetNativePointerField<TSubclassOf<APrimalBuff>*>(this, "AShooterWeapon.ScopedBuff"); }
    TWeakObjectPtr<APrimalBuff>& MyScopedBuffField() { return *GetNativePointerField<TWeakObjectPtr<APrimalBuff>*>(this, "AShooterWeapon.MyScopedBuff"); }
    UAnimSequence* OverrideTPVShieldAnimationField() { return *GetNativePointerField<UAnimSequence**>(this, "AShooterWeapon.OverrideTPVShieldAnimation"); }
    bool& bAllowTargetingDuringMeleeSwingField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bAllowTargetingDuringMeleeSwing"); }
    FVector& FPVMuzzleLocationOffsetField() { return *GetNativePointerField<FVector*>(this, "AShooterWeapon.FPVMuzzleLocationOffset"); }
    FVector& TPVMuzzleLocationOffsetField() { return *GetNativePointerField<FVector*>(this, "AShooterWeapon.TPVMuzzleLocationOffset"); }
    bool& bForceTPV_EquippedWhileRidingField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bForceTPV_EquippedWhileRiding"); }
    bool& bCutsEnemyGrapplingCableField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bCutsEnemyGrapplingCable"); }
    FVector& FPVInventoryReequipOffsetField() { return *GetNativePointerField<FVector*>(this, "AShooterWeapon.FPVInventoryReequipOffset"); }
    long double& LocalInventoryViewingSkippedEquipAnimTimeField() { return *GetNativePointerField<long double*>(this, "AShooterWeapon.LocalInventoryViewingSkippedEquipAnimTime"); }
    float& DraggingOffsetInterpField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.DraggingOffsetInterp"); }
    bool& bForceTPVCameraOffsetField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bForceTPVCameraOffset"); }
    bool& bUseBPSpawnMeleeEffectsField() { return *GetNativePointerField<bool*>(this, "AShooterWeapon.bUseBPSpawnMeleeEffects"); }
 
    // Bit fields
 
    BitFieldValue<bool, unsigned __int32> bUseDinoRangeForTooltip() { return { this, "AShooterWeapon.bUseDinoRangeForTooltip" }; }
    BitFieldValue<bool, unsigned __int32> bFPVUsingImmobilizedTransform() { return { this, "AShooterWeapon.bFPVUsingImmobilizedTransform" }; }
    BitFieldValue<bool, unsigned __int32> bOnlyUseFirstMeleeAnimWithShield() { return { this, "AShooterWeapon.bOnlyUseFirstMeleeAnimWithShield" }; }
    BitFieldValue<bool, unsigned __int32> bForceShowCrosshairWhileFiring() { return { this, "AShooterWeapon.bForceShowCrosshairWhileFiring" }; }
    BitFieldValue<bool, unsigned __int32> bIsFireActivelyHeld() { return { this, "AShooterWeapon.bIsFireActivelyHeld" }; }
    BitFieldValue<bool, unsigned __int32> bAllowSubmergedFiring() { return { this, "AShooterWeapon.bAllowSubmergedFiring" }; }
    BitFieldValue<bool, unsigned __int32> bIsInMeleeSwing() { return { this, "AShooterWeapon.bIsInMeleeSwing" }; }
    BitFieldValue<bool, unsigned __int32> bDoMeleeSwing() { return { this, "AShooterWeapon.bDoMeleeSwing" }; }
    BitFieldValue<bool, unsigned __int32> bPlayingCameraAnimFPV() { return { this, "AShooterWeapon.bPlayingCameraAnimFPV" }; }
    BitFieldValue<bool, unsigned __int32> bIsWeaponBreaking() { return { this, "AShooterWeapon.bIsWeaponBreaking" }; }
    BitFieldValue<bool, unsigned __int32> bHideFPVMesh() { return { this, "AShooterWeapon.bHideFPVMesh" }; }
    BitFieldValue<bool, unsigned __int32> bForceTargeting() { return { this, "AShooterWeapon.bForceTargeting" }; }
    BitFieldValue<bool, unsigned __int32> bCanAltFire() { return { this, "AShooterWeapon.bCanAltFire" }; }
    BitFieldValue<bool, unsigned __int32> bAltFireDoesMeleeAttack() { return { this, "AShooterWeapon.bAltFireDoesMeleeAttack" }; }
    BitFieldValue<bool, unsigned __int32> bAltFireDoesNotStopFire() { return { this, "AShooterWeapon.bAltFireDoesNotStopFire" }; }
    BitFieldValue<bool, unsigned __int32> bHideDamageSourceFromLogs() { return { this, "AShooterWeapon.bHideDamageSourceFromLogs" }; }
    BitFieldValue<bool, unsigned __int32> bUseTargetingFireAnim() { return { this, "AShooterWeapon.bUseTargetingFireAnim" }; }
    BitFieldValue<bool, unsigned __int32> bUseTargetingReloadAnim() { return { this, "AShooterWeapon.bUseTargetingReloadAnim" }; }
    BitFieldValue<bool, unsigned __int32> bUsePartialReloadAnim() { return { this, "AShooterWeapon.bUsePartialReloadAnim" }; }
    BitFieldValue<bool, unsigned __int32> bUseEquipNoAmmoClipAnim() { return { this, "AShooterWeapon.bUseEquipNoAmmoClipAnim" }; }
    BitFieldValue<bool, unsigned __int32> bUseUnequipNoAmmoClipAnim() { return { this, "AShooterWeapon.bUseUnequipNoAmmoClipAnim" }; }
    BitFieldValue<bool, unsigned __int32> bUseMeleeNoAmmoClipAnim() { return { this, "AShooterWeapon.bUseMeleeNoAmmoClipAnim" }; }
    BitFieldValue<bool, unsigned __int32> bHideLeftArmFPV() { return { this, "AShooterWeapon.bHideLeftArmFPV" }; }
    BitFieldValue<bool, unsigned __int32> bLoopedMuzzleFX() { return { this, "AShooterWeapon.bLoopedMuzzleFX" }; }
    BitFieldValue<bool, unsigned __int32> bMeleeHitUseMuzzleFX() { return { this, "AShooterWeapon.bMeleeHitUseMuzzleFX" }; }
    BitFieldValue<bool, unsigned __int32> bUsePostUpdateTickForFPVParticles() { return { this, "AShooterWeapon.bUsePostUpdateTickForFPVParticles" }; }
    BitFieldValue<bool, unsigned __int32> bFPVMoveOffscreenWhenTurning() { return { this, "AShooterWeapon.bFPVMoveOffscreenWhenTurning" }; }
    BitFieldValue<bool, unsigned __int32> bReloadAnimForceTickPoseOnServer() { return { this, "AShooterWeapon.bReloadAnimForceTickPoseOnServer" }; }
    BitFieldValue<bool, unsigned __int32> bLoopedFireSound() { return { this, "AShooterWeapon.bLoopedFireSound" }; }
    BitFieldValue<bool, unsigned __int32> bAllowTargetingWhileReloading() { return { this, "AShooterWeapon.bAllowTargetingWhileReloading" }; }
    BitFieldValue<bool, unsigned __int32> bMeleeHitColorizesStructures() { return { this, "AShooterWeapon.bMeleeHitColorizesStructures" }; }
    BitFieldValue<bool, unsigned __int32> bLoopedFireAnim() { return { this, "AShooterWeapon.bLoopedFireAnim" }; }
    BitFieldValue<bool, unsigned __int32> bPlayingFireAnim() { return { this, "AShooterWeapon.bPlayingFireAnim" }; }
    BitFieldValue<bool, unsigned __int32> bFPVWasTurning() { return { this, "AShooterWeapon.bFPVWasTurning" }; }
    BitFieldValue<bool, unsigned __int32> bAutoRefire() { return { this, "AShooterWeapon.bAutoRefire" }; }
    BitFieldValue<bool, unsigned __int32> bConsumeAmmoOnUseAmmo() { return { this, "AShooterWeapon.bConsumeAmmoOnUseAmmo" }; }
    BitFieldValue<bool, unsigned __int32> bTargetUnTargetWithClick() { return { this, "AShooterWeapon.bTargetUnTargetWithClick" }; }
    BitFieldValue<bool, unsigned __int32> bDontActuallyConsumeItemAmmo() { return { this, "AShooterWeapon.bDontActuallyConsumeItemAmmo" }; }
    BitFieldValue<bool, unsigned __int32> bBPUseWeaponCanFire() { return { this, "AShooterWeapon.bBPUseWeaponCanFire" }; }
    BitFieldValue<bool, unsigned __int32> bBPUseTargetingEvents() { return { this, "AShooterWeapon.bBPUseTargetingEvents" }; }
    BitFieldValue<bool, unsigned __int32> bIsEquipped() { return { this, "AShooterWeapon.bIsEquipped" }; }
    BitFieldValue<bool, unsigned __int32> bWantsToFire() { return { this, "AShooterWeapon.bWantsToFire" }; }
    BitFieldValue<bool, unsigned __int32> bWantsToAltFire() { return { this, "AShooterWeapon.bWantsToAltFire" }; }
    BitFieldValue<bool, unsigned __int32> bPendingReload() { return { this, "AShooterWeapon.bPendingReload" }; }
    BitFieldValue<bool, unsigned __int32> bPendingEquip() { return { this, "AShooterWeapon.bPendingEquip" }; }
    BitFieldValue<bool, unsigned __int32> bUnequipping() { return { this, "AShooterWeapon.bUnequipping" }; }
    BitFieldValue<bool, unsigned __int32> bNotifiedOutOfAmmo() { return { this, "AShooterWeapon.bNotifiedOutOfAmmo" }; }
    BitFieldValue<bool, unsigned __int32> bPlayedTargetingSound() { return { this, "AShooterWeapon.bPlayedTargetingSound" }; }
    BitFieldValue<bool, unsigned __int32> bUseAmmoOnFiring() { return { this, "AShooterWeapon.bUseAmmoOnFiring" }; }
    BitFieldValue<bool, unsigned __int32> bUseAmmoServerOnly() { return { this, "AShooterWeapon.bUseAmmoServerOnly" }; }
    BitFieldValue<bool, unsigned __int32> bListenToAppliedForeces() { return { this, "AShooterWeapon.bListenToAppliedForeces" }; }
    BitFieldValue<bool, unsigned __int32> bOverrideAimOffsets() { return { this, "AShooterWeapon.bOverrideAimOffsets" }; }
    BitFieldValue<bool, unsigned __int32> bHasToggleableAccessory() { return { this, "AShooterWeapon.bHasToggleableAccessory" }; }
    BitFieldValue<bool, unsigned __int32> bToggleAccessoryUseAltMuzzleFX() { return { this, "AShooterWeapon.bToggleAccessoryUseAltMuzzleFX" }; }
    BitFieldValue<bool, unsigned __int32> bToggleAccessoryUseAltFireSound() { return { this, "AShooterWeapon.bToggleAccessoryUseAltFireSound" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPCanToggleAccessory() { return { this, "AShooterWeapon.bUseBPCanToggleAccessory" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOnScoped() { return { this, "AShooterWeapon.bUseBPOnScoped" }; }
    BitFieldValue<bool, unsigned __int32> bIsDefaultWeapon() { return { this, "AShooterWeapon.bIsDefaultWeapon" }; }
    BitFieldValue<bool, unsigned __int32> bForceKeepEquippedWhileInInventory() { return { this, "AShooterWeapon.bForceKeepEquippedWhileInInventory" }; }
    BitFieldValue<bool, unsigned __int32> bOnlyAllowUseWhenRidingDino() { return { this, "AShooterWeapon.bOnlyAllowUseWhenRidingDino" }; }
    BitFieldValue<bool, unsigned __int32> bPrimaryFireDoesMeleeAttack() { return { this, "AShooterWeapon.bPrimaryFireDoesMeleeAttack" }; }
    BitFieldValue<bool, unsigned __int32> bMeleeHitCaptureDermis() { return { this, "AShooterWeapon.bMeleeHitCaptureDermis" }; }
    BitFieldValue<bool, unsigned __int32> bIsAccessoryActive() { return { this, "AShooterWeapon.bIsAccessoryActive" }; }
    BitFieldValue<bool, unsigned __int32> bCanAccessoryBeSetOn() { return { this, "AShooterWeapon.bCanAccessoryBeSetOn" }; }
    BitFieldValue<bool, unsigned __int32> bConsumeAmmoItemOnReload() { return { this, "AShooterWeapon.bConsumeAmmoItemOnReload" }; }
    BitFieldValue<bool, unsigned __int32> bUseAutoReload() { return { this, "AShooterWeapon.bUseAutoReload" }; }
    BitFieldValue<bool, unsigned __int32> bWantsToAutoReload() { return { this, "AShooterWeapon.bWantsToAutoReload" }; }
    BitFieldValue<bool, unsigned __int32> bHasPlayedReload() { return { this, "AShooterWeapon.bHasPlayedReload" }; }
    BitFieldValue<bool, unsigned __int32> bNetLoopedSimulatingWeaponFire() { return { this, "AShooterWeapon.bNetLoopedSimulatingWeaponFire" }; }
    BitFieldValue<bool, unsigned __int32> bClientLoopingSimulateWeaponFire() { return { this, "AShooterWeapon.bClientLoopingSimulateWeaponFire" }; }
    BitFieldValue<bool, unsigned __int32> bBPHandleMeleeAttack() { return { this, "AShooterWeapon.bBPHandleMeleeAttack" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPShouldDealDamage() { return { this, "AShooterWeapon.bUseBPShouldDealDamage" }; }
    BitFieldValue<bool, unsigned __int32> bDoesntUsePrimalItem() { return { this, "AShooterWeapon.bDoesntUsePrimalItem" }; }
    BitFieldValue<bool, unsigned __int32> bUseCanAccessoryBeSetOn() { return { this, "AShooterWeapon.bUseCanAccessoryBeSetOn" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPGetActorForTargetingTooltip() { return { this, "AShooterWeapon.bUseBPGetActorForTargetingTooltip" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOverrideAimDirection() { return { this, "AShooterWeapon.bUseBPOverrideAimDirection" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPIsValidUnstasisActor() { return { this, "AShooterWeapon.bUseBPIsValidUnstasisActor" }; }
    BitFieldValue<bool, unsigned __int32> bLoopingSimulateWeaponFire() { return { this, "AShooterWeapon.bLoopingSimulateWeaponFire" }; }
    BitFieldValue<bool, unsigned __int32> bFiredFirstBurstShot() { return { this, "AShooterWeapon.bFiredFirstBurstShot" }; }
    BitFieldValue<bool, unsigned __int32> bClientTriggersHandleFiring() { return { this, "AShooterWeapon.bClientTriggersHandleFiring" }; }
    BitFieldValue<bool, unsigned __int32> bAllowUseHarvesting() { return { this, "AShooterWeapon.bAllowUseHarvesting" }; }
    BitFieldValue<bool, unsigned __int32> bPreventItemColors() { return { this, "AShooterWeapon.bPreventItemColors" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPGetSelectedMeleeAttackAnim() { return { this, "AShooterWeapon.bUseBPGetSelectedMeleeAttackAnim" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPWeaponDealDamage() { return { this, "AShooterWeapon.bUseBPWeaponDealDamage" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOnWeaponAnimPlayedNotify() { return { this, "AShooterWeapon.bUseBPOnWeaponAnimPlayedNotify" }; }
    BitFieldValue<bool, unsigned __int32> bColorCrosshairBasedOnTarget() { return { this, "AShooterWeapon.bColorCrosshairBasedOnTarget" }; }
    BitFieldValue<bool, unsigned __int32> bAllowTargeting() { return { this, "AShooterWeapon.bAllowTargeting" }; }
    BitFieldValue<bool, unsigned __int32> bAllowDropAndPickup() { return { this, "AShooterWeapon.bAllowDropAndPickup" }; }
    BitFieldValue<bool, unsigned __int32> bApplyAimDriftWhenTargeting() { return { this, "AShooterWeapon.bApplyAimDriftWhenTargeting" }; }
    BitFieldValue<bool, unsigned __int32> bUseScopeOverlay() { return { this, "AShooterWeapon.bUseScopeOverlay" }; }
    BitFieldValue<bool, unsigned __int32> bHideFPVMeshWhileTargeting() { return { this, "AShooterWeapon.bHideFPVMeshWhileTargeting" }; }
    BitFieldValue<bool, unsigned __int32> bGamepadRightIsSecondaryAction() { return { this, "AShooterWeapon.bGamepadRightIsSecondaryAction" }; }
    BitFieldValue<bool, unsigned __int32> bGamepadLeftIsPrimaryFire() { return { this, "AShooterWeapon.bGamepadLeftIsPrimaryFire" }; }
    BitFieldValue<bool, unsigned __int32> bDirectPrimaryFireToAltFire() { return { this, "AShooterWeapon.bDirectPrimaryFireToAltFire" }; }
    BitFieldValue<bool, unsigned __int32> bCanFire() { return { this, "AShooterWeapon.bCanFire" }; }
    BitFieldValue<bool, unsigned __int32> bForceTargetingOnDino() { return { this, "AShooterWeapon.bForceTargetingOnDino" }; }
    BitFieldValue<bool, unsigned __int32> bDirectTargetingToPrimaryFire() { return { this, "AShooterWeapon.bDirectTargetingToPrimaryFire" }; }
    BitFieldValue<bool, unsigned __int32> bDirectTargetingToAltFire() { return { this, "AShooterWeapon.bDirectTargetingToAltFire" }; }
    BitFieldValue<bool, unsigned __int32> bDirectTargetingToSecondaryAction() { return { this, "AShooterWeapon.bDirectTargetingToSecondaryAction" }; }
    BitFieldValue<bool, unsigned __int32> bPreventEquippingUnderwater() { return { this, "AShooterWeapon.bPreventEquippingUnderwater" }; }
    BitFieldValue<bool, unsigned __int32> bUseTPVWeaponMeshMeleeSockets() { return { this, "AShooterWeapon.bUseTPVWeaponMeshMeleeSockets" }; }
    BitFieldValue<bool, unsigned __int32> bTargetingForceTraceFloatingHUD() { return { this, "AShooterWeapon.bTargetingForceTraceFloatingHUD" }; }
    BitFieldValue<bool, unsigned __int32> bAllowRunning() { return { this, "AShooterWeapon.bAllowRunning" }; }
    BitFieldValue<bool, unsigned __int32> bAllowUseWhileRidingDino() { return { this, "AShooterWeapon.bAllowUseWhileRidingDino" }; }
    BitFieldValue<bool, unsigned __int32> bSupportsOffhandShield() { return { this, "AShooterWeapon.bSupportsOffhandShield" }; }
    BitFieldValue<bool, unsigned __int32> bMeleeAttackHarvetUsableComponents() { return { this, "AShooterWeapon.bMeleeAttackHarvetUsableComponents" }; }
    BitFieldValue<bool, unsigned __int32> bAllowSettingColorizeRegions() { return { this, "AShooterWeapon.bAllowSettingColorizeRegions" }; }
    BitFieldValue<bool, unsigned __int32> bAttemptToDyeWithMeleeAttack() { return { this, "AShooterWeapon.bAttemptToDyeWithMeleeAttack" }; }
    BitFieldValue<bool, unsigned __int32> bOnlyDamagePawns() { return { this, "AShooterWeapon.bOnlyDamagePawns" }; }
    BitFieldValue<bool, unsigned __int32> bUseCharacterMeleeDamageModifier() { return { this, "AShooterWeapon.bUseCharacterMeleeDamageModifier" }; }
    BitFieldValue<bool, unsigned __int32> bConsumeZoomInOut() { return { this, "AShooterWeapon.bConsumeZoomInOut" }; }
    BitFieldValue<bool, unsigned __int32> bClipScopeInY() { return { this, "AShooterWeapon.bClipScopeInY" }; }
    BitFieldValue<bool, unsigned __int32> bScopeFullscreen() { return { this, "AShooterWeapon.bScopeFullscreen" }; }
    BitFieldValue<bool, unsigned __int32> bAllowRunningWhileFiring() { return { this, "AShooterWeapon.bAllowRunningWhileFiring" }; }
    BitFieldValue<bool, unsigned __int32> bAllowRunningWhileReloading() { return { this, "AShooterWeapon.bAllowRunningWhileReloading" }; }
    BitFieldValue<bool, unsigned __int32> bAllowRunningWhileMeleeAttacking() { return { this, "AShooterWeapon.bAllowRunningWhileMeleeAttacking" }; }
    BitFieldValue<bool, unsigned __int32> bColorizeMuzzleFX() { return { this, "AShooterWeapon.bColorizeMuzzleFX" }; }
    BitFieldValue<bool, unsigned __int32> bForceFirstPersonWhileTargeting() { return { this, "AShooterWeapon.bForceFirstPersonWhileTargeting" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPStartEquippedNotify() { return { this, "AShooterWeapon.bUseBPStartEquippedNotify" }; }
    BitFieldValue<bool, unsigned __int32> bDirectPrimaryFireToSecondaryAction() { return { this, "AShooterWeapon.bDirectPrimaryFireToSecondaryAction" }; }
    BitFieldValue<bool, unsigned __int32> bUseAlternateAimOffset() { return { this, "AShooterWeapon.bUseAlternateAimOffset" }; }
    BitFieldValue<bool, unsigned __int32> bOverrideStandingAnim() { return { this, "AShooterWeapon.bOverrideStandingAnim" }; }
    BitFieldValue<bool, unsigned __int32> bUseCustomSeatedAnim() { return { this, "AShooterWeapon.bUseCustomSeatedAnim" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPForceTPVTargetingAnimation() { return { this, "AShooterWeapon.bUseBPForceTPVTargetingAnimation" }; }
    BitFieldValue<bool, unsigned __int32> bForcePreventUseWhileRidingDino() { return { this, "AShooterWeapon.bForcePreventUseWhileRidingDino" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPPreventSwitchingWeapon() { return { this, "AShooterWeapon.bUseBPPreventSwitchingWeapon" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPCanEquip() { return { this, "AShooterWeapon.bUseBPCanEquip" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPRemainEquipped() { return { this, "AShooterWeapon.bUseBPRemainEquipped" }; }
    BitFieldValue<bool, unsigned __int32> bIsInDestruction() { return { this, "AShooterWeapon.bIsInDestruction" }; }
    BitFieldValue<bool, unsigned __int32> bForceReloadOnDestruction() { return { this, "AShooterWeapon.bForceReloadOnDestruction" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPModifyFOV() { return { this, "AShooterWeapon.bUseBPModifyFOV" }; }
    BitFieldValue<bool, unsigned __int32> bServerIgnoreCheckCanFire() { return { this, "AShooterWeapon.bServerIgnoreCheckCanFire" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPGetTPVCameraOffset() { return { this, "AShooterWeapon.bUseBPGetTPVCameraOffset" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOverrideRootRotationOffset() { return { this, "AShooterWeapon.bUseBPOverrideRootRotationOffset" }; }
    BitFieldValue<bool, unsigned __int32> bSpawnedByMission() { return { this, "AShooterWeapon.bSpawnedByMission" }; }
    BitFieldValue<bool, unsigned __int32> bForceAlwaysPlayEquipAnim() { return { this, "AShooterWeapon.bForceAlwaysPlayEquipAnim" }; }
    BitFieldValue<bool, unsigned __int32> bLastMeleeAttacked() { return { this, "AShooterWeapon.bLastMeleeAttacked" }; }
    BitFieldValue<bool, unsigned __int32> bIgnoreReloadState() { return { this, "AShooterWeapon.bIgnoreReloadState" }; }
 
    // Functions
 
    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "AShooterWeapon.StaticClass"); }
    static ABrush* GetStandingAnimation_Implementation(TSubclassOf<ABrush> BrushType, FTransform* BrushTransform, FVector BoxExtent) { return NativeCall<ABrush*, TSubclassOf<ABrush>, FTransform*, FVector>(nullptr, "AShooterWeapon.GetStandingAnimation_Implementation", BrushType, BrushTransform, BoxExtent); }
    bool IsPlayingCameraAnimFPV() { return NativeCall<bool>(this, "AShooterWeapon.IsPlayingCameraAnimFPV"); }
    USceneComponent* FindComponentByName(FName ComponentName) { return NativeCall<USceneComponent*, FName>(this, "AShooterWeapon.FindComponentByName", ComponentName); }
    void ZoomOut() { NativeCall<void>(this, "AShooterWeapon.ZoomOut"); }
    void ZoomIn() { NativeCall<void>(this, "AShooterWeapon.ZoomIn"); }
    bool UseAlternateAimOffsetAnim() { return NativeCall<bool>(this, "AShooterWeapon.UseAlternateAimOffsetAnim"); }
    void PostInitializeComponents() { NativeCall<void>(this, "AShooterWeapon.PostInitializeComponents"); }
    void DrawHUD(AShooterHUD* HUD) { NativeCall<void, AShooterHUD*>(this, "AShooterWeapon.DrawHUD", HUD); }
    void UpdateFirstPersonMeshes(bool bIsFirstPerson) { NativeCall<void, bool>(this, "AShooterWeapon.UpdateFirstPersonMeshes", bIsFirstPerson); }
    void Destroyed() { NativeCall<void>(this, "AShooterWeapon.Destroyed"); }
    bool IsValidUnStasisCaster() { return NativeCall<bool>(this, "AShooterWeapon.IsValidUnStasisCaster"); }
    void OnEquip() { NativeCall<void>(this, "AShooterWeapon.OnEquip"); }
    void OnEquipFinished() { NativeCall<void>(this, "AShooterWeapon.OnEquipFinished"); }
    void StartUnequip_Implementation() { NativeCall<void>(this, "AShooterWeapon.StartUnequip_Implementation"); }
    void PlayUnequipAnimation() { NativeCall<void>(this, "AShooterWeapon.PlayUnequipAnimation"); }
    void AttachMeshToPawn() { NativeCall<void>(this, "AShooterWeapon.AttachMeshToPawn"); }
    void ApplyPrimalItemSettingsToWeapon(bool bShallowUpdate) { NativeCall<void, bool>(this, "AShooterWeapon.ApplyPrimalItemSettingsToWeapon", bShallowUpdate); }
    void DetachMeshFromPawn() { NativeCall<void>(this, "AShooterWeapon.DetachMeshFromPawn"); }
    void ApplyCharacterSnapshot(UPrimalItem* SnapshotItem, AActor* To) { NativeCall<void, UPrimalItem*, AActor*>(this, "AShooterWeapon.ApplyCharacterSnapshot", SnapshotItem, To); }
    bool AllowedToFire(bool bForceAllowSubmergedFiring) { return NativeCall<bool, bool>(this, "AShooterWeapon.AllowedToFire", bForceAllowSubmergedFiring); }
    void StartFire(bool bFromGamepad) { NativeCall<void, bool>(this, "AShooterWeapon.StartFire", bFromGamepad); }
    void StopFire() { NativeCall<void>(this, "AShooterWeapon.StopFire"); }
    void StartAltFire() { NativeCall<void>(this, "AShooterWeapon.StartAltFire"); }
    void StartSecondaryAction() { NativeCall<void>(this, "AShooterWeapon.StartSecondaryAction"); }
    void StopSecondaryAction() { NativeCall<void>(this, "AShooterWeapon.StopSecondaryAction"); }
    void OnStartTargeting(bool bFromGamepadLeft) { NativeCall<void, bool>(this, "AShooterWeapon.OnStartTargeting", bFromGamepadLeft); }
    void OnStopTargeting(bool bFromGamepadLeft) { NativeCall<void, bool>(this, "AShooterWeapon.OnStopTargeting", bFromGamepadLeft); }
    bool CanToggleAccessory() { return NativeCall<bool>(this, "AShooterWeapon.CanToggleAccessory"); }
    void SetAccessoryEnabled(bool bEnabled) { NativeCall<void, bool>(this, "AShooterWeapon.SetAccessoryEnabled", bEnabled); }
    void ToggleAccessory() { NativeCall<void>(this, "AShooterWeapon.ToggleAccessory"); }
    void RefreshToggleAccessory() { NativeCall<void>(this, "AShooterWeapon.RefreshToggleAccessory"); }
    bool CanMeleeAttack() { return NativeCall<bool>(this, "AShooterWeapon.CanMeleeAttack"); }
    void DoMeleeAttack() { NativeCall<void>(this, "AShooterWeapon.DoMeleeAttack"); }
    void StopAltFire() { NativeCall<void>(this, "AShooterWeapon.StopAltFire"); }
    void CheckForMeleeAttack() { NativeCall<void>(this, "AShooterWeapon.CheckForMeleeAttack"); }
    void StopCheckForMeleeAttack() { NativeCall<void>(this, "AShooterWeapon.StopCheckForMeleeAttack"); }
    bool CanRun() { return NativeCall<bool>(this, "AShooterWeapon.CanRun"); }
    void StartReload(bool bFromReplication) { NativeCall<void, bool>(this, "AShooterWeapon.StartReload", bFromReplication); }
    void ClearClientReload() { NativeCall<void>(this, "AShooterWeapon.ClearClientReload"); }
    float PlayReloadAnimation() { return NativeCall<float>(this, "AShooterWeapon.PlayReloadAnimation"); }
    void StopReloadAnimation() { NativeCall<void>(this, "AShooterWeapon.StopReloadAnimation"); }
    void ServerStartFire_Implementation() { NativeCall<void>(this, "AShooterWeapon.ServerStartFire_Implementation"); }
    void ServerStopFire_Implementation() { NativeCall<void>(this, "AShooterWeapon.ServerStopFire_Implementation"); }
    void ServerStartAltFire_Implementation() { NativeCall<void>(this, "AShooterWeapon.ServerStartAltFire_Implementation"); }
    void ServerStopAltFire_Implementation() { NativeCall<void>(this, "AShooterWeapon.ServerStopAltFire_Implementation"); }
    void ServerStartSecondaryAction_Implementation() { NativeCall<void>(this, "AShooterWeapon.ServerStartSecondaryAction_Implementation"); }
    void ServerStopSecondaryAction_Implementation() { NativeCall<void>(this, "AShooterWeapon.ServerStopSecondaryAction_Implementation"); }
    void ServerToggleAccessory_Implementation() { NativeCall<void>(this, "AShooterWeapon.ServerToggleAccessory_Implementation"); }
    void ServerStartReload_Implementation() { NativeCall<void>(this, "AShooterWeapon.ServerStartReload_Implementation"); }
    void ClientStartReload_Implementation() { NativeCall<void>(this, "AShooterWeapon.ClientStartReload_Implementation"); }
    bool CanFire(bool bForceAllowSubmergedFiring) { return NativeCall<bool, bool>(this, "AShooterWeapon.CanFire", bForceAllowSubmergedFiring); }
    bool AllowFiring() { return NativeCall<bool>(this, "AShooterWeapon.AllowFiring"); }
    bool CanReload() { return NativeCall<bool>(this, "AShooterWeapon.CanReload"); }
    void UseAmmo(int UseAmmoAmountOverride) { NativeCall<void, int>(this, "AShooterWeapon.UseAmmo", UseAmmoAmountOverride); }
    float GetFireCameraShakeScale() { return NativeCall<float>(this, "AShooterWeapon.GetFireCameraShakeScale"); }
    void HandleFiring(bool bSentFromClient) { NativeCall<void, bool>(this, "AShooterWeapon.HandleFiring", bSentFromClient); }
    bool CanTarget() { return NativeCall<bool>(this, "AShooterWeapon.CanTarget"); }
    float GetConsumeDurabilityPerShot() { return NativeCall<float>(this, "AShooterWeapon.GetConsumeDurabilityPerShot"); }
    void ReloadWeapon() { NativeCall<void>(this, "AShooterWeapon.ReloadWeapon"); }
    void RefreshAmmoItemQuantity() { NativeCall<void>(this, "AShooterWeapon.RefreshAmmoItemQuantity"); }
    void ConsumeAmmoItem(int Quantity) { NativeCall<void, int>(this, "AShooterWeapon.ConsumeAmmoItem", Quantity); }
    void SetWeaponState(EWeaponState::Type NewState) { NativeCall<void, EWeaponState::Type>(this, "AShooterWeapon.SetWeaponState", NewState); }
    void DetermineWeaponState() { NativeCall<void>(this, "AShooterWeapon.DetermineWeaponState"); }
    void SetAutoReload() { NativeCall<void>(this, "AShooterWeapon.SetAutoReload"); }
    void OnBurstStarted() { NativeCall<void>(this, "AShooterWeapon.OnBurstStarted"); }
    void OnBurstFinished() { NativeCall<void>(this, "AShooterWeapon.OnBurstFinished"); }
    bool IsSimulated() { return NativeCall<bool>(this, "AShooterWeapon.IsSimulated"); }
    void ClientStopSimulatingWeaponFire_Implementation() { NativeCall<void>(this, "AShooterWeapon.ClientStopSimulatingWeaponFire_Implementation"); }
    void ClientSimulateWeaponFire_Implementation() { NativeCall<void>(this, "AShooterWeapon.ClientSimulateWeaponFire_Implementation"); }
    UAudioComponent* PlayWeaponSound(USoundCue* Sound) { return NativeCall<UAudioComponent*, USoundCue*>(this, "AShooterWeapon.PlayWeaponSound", Sound); }
    float PlayCameraAnimationFPV(UAnimMontage* Animation1P) { return NativeCall<float, UAnimMontage*>(this, "AShooterWeapon.PlayCameraAnimationFPV", Animation1P); }
    void StopCameraAnimationFPV() { NativeCall<void>(this, "AShooterWeapon.StopCameraAnimationFPV"); }
    void ClientPlayShieldHitAnim_Implementation() { NativeCall<void>(this, "AShooterWeapon.ClientPlayShieldHitAnim_Implementation"); }
    FVector* GetAdjustedAim(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AShooterWeapon.GetAdjustedAim", result); }
    FVector* GetCameraDamageStartLocation(FVector* result, FVector* AimDir) { return NativeCall<FVector*, FVector*, FVector*>(this, "AShooterWeapon.GetCameraDamageStartLocation", result, AimDir); }
    FVector* GetShootingCameraLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AShooterWeapon.GetShootingCameraLocation", result); }
    FVector* GetMuzzleLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AShooterWeapon.GetMuzzleLocation", result); }
    FVector* GetMuzzleDirection(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AShooterWeapon.GetMuzzleDirection", result); }
    FHitResult* WeaponTrace(FHitResult* result, FVector* StartTrace, FVector* EndTrace) { return NativeCall<FHitResult*, FHitResult*, FVector*, FVector*>(this, "AShooterWeapon.WeaponTrace", result, StartTrace, EndTrace); }
    void WeaponTraceHits(TArray<FHitResult>* HitResults, FVector* StartTrace, FVector* EndTrace) { NativeCall<void, TArray<FHitResult>*, FVector*, FVector*>(this, "AShooterWeapon.WeaponTraceHits", HitResults, StartTrace, EndTrace); }
    void SetOwningPawn(AShooterCharacter* NewOwner) { NativeCall<void, AShooterCharacter*>(this, "AShooterWeapon.SetOwningPawn", NewOwner); }
    void OnCameraUpdate(FVector* CameraLocation, FRotator* CameraRotation, FVector* WeaponBob) { NativeCall<void, FVector*, FRotator*, FVector*>(this, "AShooterWeapon.OnCameraUpdate", CameraLocation, CameraRotation, WeaponBob); }
    void OnRep_MyPawn() { NativeCall<void>(this, "AShooterWeapon.OnRep_MyPawn"); }
    void OnRep_AccessoryToggle() { NativeCall<void>(this, "AShooterWeapon.OnRep_AccessoryToggle"); }
    void SimulateWeaponFire() { NativeCall<void>(this, "AShooterWeapon.SimulateWeaponFire"); }
    void StartMuzzleFX() { NativeCall<void>(this, "AShooterWeapon.StartMuzzleFX"); }
    void StopMuzzleFX() { NativeCall<void>(this, "AShooterWeapon.StopMuzzleFX"); }
    void PlayFireAnimation() { NativeCall<void>(this, "AShooterWeapon.PlayFireAnimation"); }
    void StopSimulatingWeaponFire() { NativeCall<void>(this, "AShooterWeapon.StopSimulatingWeaponFire"); }
    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "AShooterWeapon.GetLifetimeReplicatedProps", OutLifetimeProps); }
    AShooterCharacter* GetPawnOwner() { return NativeCall<AShooterCharacter*>(this, "AShooterWeapon.GetPawnOwner"); }
    EWeaponState::Type GetCurrentState() { return NativeCall<EWeaponState::Type>(this, "AShooterWeapon.GetCurrentState"); }
    int GetCurrentAmmo() { return NativeCall<int>(this, "AShooterWeapon.GetCurrentAmmo"); }
    int GetCurrentAmmoInClip() { return NativeCall<int>(this, "AShooterWeapon.GetCurrentAmmoInClip"); }
    bool UsesAmmo() { return NativeCall<bool>(this, "AShooterWeapon.UsesAmmo"); }
    bool HasInfiniteAmmo() { return NativeCall<bool>(this, "AShooterWeapon.HasInfiniteAmmo"); }
    void StartMeleeSwing() { NativeCall<void>(this, "AShooterWeapon.StartMeleeSwing"); }
    void EndMeleeSwing() { NativeCall<void>(this, "AShooterWeapon.EndMeleeSwing"); }
    void EndDoMeleeSwing() { NativeCall<void>(this, "AShooterWeapon.EndDoMeleeSwing"); }
    bool AddToMeleeSwingHurtList(AActor* AnActor) { return NativeCall<bool, AActor*>(this, "AShooterWeapon.AddToMeleeSwingHurtList", AnActor); }
    bool ShouldDealDamage(AActor* TestActor) { return NativeCall<bool, AActor*>(this, "AShooterWeapon.ShouldDealDamage", TestActor); }
    void DealDamage(FHitResult* Impact, FVector* ShootDir, int DamageAmount, TSubclassOf<UDamageType> DamageType, float Impulse) { NativeCall<void, FHitResult*, FVector*, int, TSubclassOf<UDamageType>, float>(this, "AShooterWeapon.DealDamage", Impact, ShootDir, DamageAmount, DamageType, Impulse); }
    float GetWeaponDamageMultiplier() { return NativeCall<float>(this, "AShooterWeapon.GetWeaponDamageMultiplier"); }
    void TickMeleeSwing(float DeltaTime) { NativeCall<void, float>(this, "AShooterWeapon.TickMeleeSwing", DeltaTime); }
    void ClientStartMuzzleFX_Implementation() { NativeCall<void>(this, "AShooterWeapon.ClientStartMuzzleFX_Implementation"); }
    void CosumeMeleeHitDurability(float DurabilityConsumptionMultiplier) { NativeCall<void, float>(this, "AShooterWeapon.CosumeMeleeHitDurability", DurabilityConsumptionMultiplier); }
    void PlayWeaponBreakAnimation_Implementation() { NativeCall<void>(this, "AShooterWeapon.PlayWeaponBreakAnimation_Implementation"); }
    void Tick(float DeltaSeconds) { NativeCall<void, float>(this, "AShooterWeapon.Tick", DeltaSeconds); }
    bool IsFiring() { return NativeCall<bool>(this, "AShooterWeapon.IsFiring"); }
    void BeginPlay() { NativeCall<void>(this, "AShooterWeapon.BeginPlay"); }
    void LocalPossessed() { NativeCall<void>(this, "AShooterWeapon.LocalPossessed"); }
    bool IsLocallyOwned() { return NativeCall<bool>(this, "AShooterWeapon.IsLocallyOwned"); }
    void CheckItemAssocation() { NativeCall<void>(this, "AShooterWeapon.CheckItemAssocation"); }
    bool IsOwningClient() { return NativeCall<bool>(this, "AShooterWeapon.IsOwningClient"); }
    void OnRep_CurrentAmmoInClip() { NativeCall<void>(this, "AShooterWeapon.OnRep_CurrentAmmoInClip"); }
    void LoadedFromSaveGame() { NativeCall<void>(this, "AShooterWeapon.LoadedFromSaveGame"); }
    void PlayUseHarvestAnimation_Implementation() { NativeCall<void>(this, "AShooterWeapon.PlayUseHarvestAnimation_Implementation"); }
    void OwnerDied() { NativeCall<void>(this, "AShooterWeapon.OwnerDied"); }
    void OnRep_NetLoopedWeaponFire() { NativeCall<void>(this, "AShooterWeapon.OnRep_NetLoopedWeaponFire"); }
    void ClientSetClipAmmo_Implementation(int newClipAmmo, bool bOnlyUpdateItem) { NativeCall<void, int, bool>(this, "AShooterWeapon.ClientSetClipAmmo_Implementation", newClipAmmo, bOnlyUpdateItem); }
    void DoHandleFiring() { NativeCall<void>(this, "AShooterWeapon.DoHandleFiring"); }
    bool IsFirstPersonMeshVisible() { return NativeCall<bool>(this, "AShooterWeapon.IsFirstPersonMeshVisible"); }
    void ServerSetColorizeRegion_Implementation(int theRegion, bool bValToUse) { NativeCall<void, int, bool>(this, "AShooterWeapon.ServerSetColorizeRegion_Implementation", theRegion, bValToUse); }
    void DoReregisterAllComponents() { NativeCall<void>(this, "AShooterWeapon.DoReregisterAllComponents"); }
    bool ForceTPVTargetingAnimation() { return NativeCall<bool>(this, "AShooterWeapon.ForceTPVTargetingAnimation"); }
    void FireWeapon() { NativeCall<void>(this, "AShooterWeapon.FireWeapon"); }
    bool PreventSwitchingWeapon() { return NativeCall<bool>(this, "AShooterWeapon.PreventSwitchingWeapon"); }
    bool ForceFirstPerson() { return NativeCall<bool>(this, "AShooterWeapon.ForceFirstPerson"); }
    bool TryFireWeapon() { return NativeCall<bool>(this, "AShooterWeapon.TryFireWeapon"); }
    bool ForcesTPVCameraOffset_Implementation() { return NativeCall<bool>(this, "AShooterWeapon.ForcesTPVCameraOffset_Implementation"); }
    void SetAmmoInClip(int newAmmo) { NativeCall<void, int>(this, "AShooterWeapon.SetAmmoInClip", newAmmo); }
    FString* GetDebugInfoString(FString* result) { return NativeCall<FString*, FString*>(this, "AShooterWeapon.GetDebugInfoString", result); }
    bool IsInMeleeAttack() { return NativeCall<bool>(this, "AShooterWeapon.IsInMeleeAttack"); }
    void ClientSpawnMeleeEffects_Implementation(FVector Impact, FVector ShootDir) { NativeCall<void, FVector, FVector>(this, "AShooterWeapon.ClientSpawnMeleeEffects_Implementation", Impact, ShootDir); }
    FString* BPGetDebugInfoString(FString* result) { return NativeCall<FString*, FString*>(this, "AShooterWeapon.BPGetDebugInfoString", result); }
    float BPModifyFOV(float inFOV) { return NativeCall<float, float>(this, "AShooterWeapon.BPModifyFOV", inFOV); }
    static void StaticRegisterNativesAShooterWeapon() { NativeCall<void>(nullptr, "AShooterWeapon.StaticRegisterNativesAShooterWeapon"); }
    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "AShooterWeapon.GetPrivateStaticClass", Package); }
    bool AllowTargeting() { return NativeCall<bool>(this, "AShooterWeapon.AllowTargeting"); }
    bool AllowUnequip() { return NativeCall<bool>(this, "AShooterWeapon.AllowUnequip"); }
    void BP_OnReloadNotify() { NativeCall<void>(this, "AShooterWeapon.BP_OnReloadNotify"); }
    int BPAdjustAmmoPerShot() { return NativeCall<int>(this, "AShooterWeapon.BPAdjustAmmoPerShot"); }
    bool BPAllowNativeFireWeapon() { return NativeCall<bool>(this, "AShooterWeapon.BPAllowNativeFireWeapon"); }
    void BPAppliedPrimalItemToWeapon() { NativeCall<void>(this, "AShooterWeapon.BPAppliedPrimalItemToWeapon"); }
    bool BPCanEquip(AShooterCharacter* ByCharacter) { return NativeCall<bool, AShooterCharacter*>(this, "AShooterWeapon.BPCanEquip", ByCharacter); }
    bool BPCanToggleAccessory() { return NativeCall<bool>(this, "AShooterWeapon.BPCanToggleAccessory"); }
    bool BPConstrainAspectRatio(float* OutAspectRatio) { return NativeCall<bool, float*>(this, "AShooterWeapon.BPConstrainAspectRatio", OutAspectRatio); }
    void BPDrawHud(AShooterHUD* HUD) { NativeCall<void, AShooterHUD*>(this, "AShooterWeapon.BPDrawHud", HUD); }
    void BPFiredWeapon() { NativeCall<void>(this, "AShooterWeapon.BPFiredWeapon"); }
    void BPFireWeapon() { NativeCall<void>(this, "AShooterWeapon.BPFireWeapon"); }
    bool BPForceTPVTargetingAnimation() { return NativeCall<bool>(this, "AShooterWeapon.BPForceTPVTargetingAnimation"); }
    AActor* BPGetActorForTargetingTooltip() { return NativeCall<AActor*>(this, "AShooterWeapon.BPGetActorForTargetingTooltip"); }
    UAnimSequence* BPGetSeatingAnimation() { return NativeCall<UAnimSequence*>(this, "AShooterWeapon.BPGetSeatingAnimation"); }
    FText* BPGetTargetingTooltipInfoLabel(FText* result) { return NativeCall<FText*, FText*>(this, "AShooterWeapon.BPGetTargetingTooltipInfoLabel", result); }
    FVector* BPGetTPVCameraOffset(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AShooterWeapon.BPGetTPVCameraOffset", result); }
    void BPGlobalFireWeapon() { NativeCall<void>(this, "AShooterWeapon.BPGlobalFireWeapon"); }
    void BPHandleMeleeAttack() { NativeCall<void>(this, "AShooterWeapon.BPHandleMeleeAttack"); }
    void BPLostController() { NativeCall<void>(this, "AShooterWeapon.BPLostController"); }
    void BPMeleeAttackStarted() { NativeCall<void>(this, "AShooterWeapon.BPMeleeAttackStarted"); }
    void BPOnScoped() { NativeCall<void>(this, "AShooterWeapon.BPOnScoped"); }
    void BPOnStartTargeting(bool bFromGamepadLeft) { NativeCall<void, bool>(this, "AShooterWeapon.BPOnStartTargeting", bFromGamepadLeft); }
    void BPOnStopTargeting(bool bFromGamepadLeft) { NativeCall<void, bool>(this, "AShooterWeapon.BPOnStopTargeting", bFromGamepadLeft); }
    FVector* BPOverrideAimDirection(FVector* result, FVector* DesiredAimDirection) { return NativeCall<FVector*, FVector*, FVector*>(this, "AShooterWeapon.BPOverrideAimDirection", result, DesiredAimDirection); }
    FRotator* BPOverrideRootRotationOffset(FRotator* result, FRotator InRootRotation) { return NativeCall<FRotator*, FRotator*, FRotator>(this, "AShooterWeapon.BPOverrideRootRotationOffset", result, InRootRotation); }
    bool BPPreventSwitchingWeapon() { return NativeCall<bool>(this, "AShooterWeapon.BPPreventSwitchingWeapon"); }
    bool BPRemainEquipped() { return NativeCall<bool>(this, "AShooterWeapon.BPRemainEquipped"); }
    bool BPShouldDealDamage(AActor* TestActor) { return NativeCall<bool, AActor*>(this, "AShooterWeapon.BPShouldDealDamage", TestActor); }
    void BPSpawnMeleeEffects(FVector Impact, FVector ShootDir) { NativeCall<void, FVector, FVector>(this, "AShooterWeapon.BPSpawnMeleeEffects", Impact, ShootDir); }
    void BPStartEquippedNotify() { NativeCall<void>(this, "AShooterWeapon.BPStartEquippedNotify"); }
    void BPStopMeleeAttack() { NativeCall<void>(this, "AShooterWeapon.BPStopMeleeAttack"); }
    void BPToggleAccessory() { NativeCall<void>(this, "AShooterWeapon.BPToggleAccessory"); }
    void BPToggleAccessoryFailed() { NativeCall<void>(this, "AShooterWeapon.BPToggleAccessoryFailed"); }
    bool BPTryFireWeapon() { return NativeCall<bool>(this, "AShooterWeapon.BPTryFireWeapon"); }
    bool BPWeaponCanFire() { return NativeCall<bool>(this, "AShooterWeapon.BPWeaponCanFire"); }
    int BPWeaponDealDamage(FHitResult* Impact, FVector* ShootDir, int DamageAmount, TSubclassOf<UDamageType> DamageType, float Impulse) { return NativeCall<int, FHitResult*, FVector*, int, TSubclassOf<UDamageType>, float>(this, "AShooterWeapon.BPWeaponDealDamage", Impact, ShootDir, DamageAmount, DamageType, Impulse); }
    void BPWeaponZoom(bool bZoomingIn) { NativeCall<void, bool>(this, "AShooterWeapon.BPWeaponZoom", bZoomingIn); }
    void ClientPlayShieldHitAnim() { NativeCall<void>(this, "AShooterWeapon.ClientPlayShieldHitAnim"); }
    void ClientSetClipAmmo(int newClipAmmo, bool bOnlyUpdateItem) { NativeCall<void, int, bool>(this, "AShooterWeapon.ClientSetClipAmmo", newClipAmmo, bOnlyUpdateItem); }
    void ClientSimulateWeaponFire() { NativeCall<void>(this, "AShooterWeapon.ClientSimulateWeaponFire"); }
    void ClientSpawnMeleeEffects(FVector Impact, FVector ShootDir) { NativeCall<void, FVector, FVector>(this, "AShooterWeapon.ClientSpawnMeleeEffects", Impact, ShootDir); }
    void ClientStartMuzzleFX() { NativeCall<void>(this, "AShooterWeapon.ClientStartMuzzleFX"); }
    void ClientStartReload() { NativeCall<void>(this, "AShooterWeapon.ClientStartReload"); }
    void ClientStopSimulatingWeaponFire() { NativeCall<void>(this, "AShooterWeapon.ClientStopSimulatingWeaponFire"); }
    bool ForcesTPVCameraOffset() { return NativeCall<bool>(this, "AShooterWeapon.ForcesTPVCameraOffset"); }
    UAnimSequence* GetStandingAnimation(float* OutBlendInTime, float* OutBlendOutTime) { return NativeCall<UAnimSequence*, float*, float*>(this, "AShooterWeapon.GetStandingAnimation", OutBlendInTime, OutBlendOutTime); }
    void OnInstigatorPlayDyingEvent() { NativeCall<void>(this, "AShooterWeapon.OnInstigatorPlayDyingEvent"); }
    void PlayUseHarvestAnimation() { NativeCall<void>(this, "AShooterWeapon.PlayUseHarvestAnimation"); }
    void PlayWeaponBreakAnimation() { NativeCall<void>(this, "AShooterWeapon.PlayWeaponBreakAnimation"); }
    void ServerSetColorizeRegion(int theRegion, bool bValToUse) { NativeCall<void, int, bool>(this, "AShooterWeapon.ServerSetColorizeRegion", theRegion, bValToUse); }
    void ServerStartAltFire() { NativeCall<void>(this, "AShooterWeapon.ServerStartAltFire"); }
    void ServerStartFire() { NativeCall<void>(this, "AShooterWeapon.ServerStartFire"); }
    void ServerStartReload() { NativeCall<void>(this, "AShooterWeapon.ServerStartReload"); }
    void ServerStartSecondaryAction() { NativeCall<void>(this, "AShooterWeapon.ServerStartSecondaryAction"); }
    void ServerStopAltFire() { NativeCall<void>(this, "AShooterWeapon.ServerStopAltFire"); }
    void ServerStopFire() { NativeCall<void>(this, "AShooterWeapon.ServerStopFire"); }
    void ServerToggleAccessory() { NativeCall<void>(this, "AShooterWeapon.ServerToggleAccessory"); }
    void StartSecondaryActionEvent() { NativeCall<void>(this, "AShooterWeapon.StartSecondaryActionEvent"); }
    void StartUnequip() { NativeCall<void>(this, "AShooterWeapon.StartUnequip"); }
    void StartUnequipEvent() { NativeCall<void>(this, "AShooterWeapon.StartUnequipEvent"); }
    void StopSecondaryActionEvent() { NativeCall<void>(this, "AShooterWeapon.StopSecondaryActionEvent"); }
};
 
struct AAIController : AController
{
    FVector & MoveTowardTargetOffsetField() { return *GetNativePointerField<FVector*>(this, "AAIController.MoveTowardTargetOffset"); }
    FVector & TargetFocalPositionOffsetField() { return *GetNativePointerField<FVector*>(this, "AAIController.TargetFocalPositionOffset"); }
    float& ReachedDestinationThresholdOffsetField() { return *GetNativePointerField<float*>(this, "AAIController.ReachedDestinationThresholdOffset"); }
    float& MovementGoalHeightField() { return *GetNativePointerField<float*>(this, "AAIController.MovementGoalHeight"); }
    unsigned int& RequestMoveIDField() { return *GetNativePointerField<unsigned int*>(this, "AAIController.RequestMoveID"); }
    TWeakObjectPtr<AActor> & CurrentGoalField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "AAIController.CurrentGoal"); }
    FVector & MoveSegmentDirectionField() { return *GetNativePointerField<FVector*>(this, "AAIController.MoveSegmentDirection"); }
    int& MoveSegmentStartIndexField() { return *GetNativePointerField<int*>(this, "AAIController.MoveSegmentStartIndex"); }
    int& MoveSegmentEndIndexField() { return *GetNativePointerField<int*>(this, "AAIController.MoveSegmentEndIndex"); }
    float& CurrentAcceptanceRadiusField() { return *GetNativePointerField<float*>(this, "AAIController.CurrentAcceptanceRadius"); }
 
    // Bit fields
 
    BitFieldValue<bool, unsigned __int32> bLOSflag() { return { this, "AAIController.bLOSflag" }; }
    BitFieldValue<bool, unsigned __int32> bSkipExtraLOSChecks() { return { this, "AAIController.bSkipExtraLOSChecks" }; }
    BitFieldValue<bool, unsigned __int32> bAllowStrafe() { return { this, "AAIController.bAllowStrafe" }; }
    BitFieldValue<bool, unsigned __int32> bWantsPlayerState() { return { this, "AAIController.bWantsPlayerState" }; }
    BitFieldValue<bool, unsigned __int32> bUse3DGoalRadius() { return { this, "AAIController.bUse3DGoalRadius" }; }
    BitFieldValue<bool, unsigned __int32> bForceInputAcceptanceRadius() { return { this, "AAIController.bForceInputAcceptanceRadius" }; }
    BitFieldValue<bool, unsigned __int32> bCurrentStopOnOverlap() { return { this, "AAIController.bCurrentStopOnOverlap" }; }
    BitFieldValue<bool, unsigned __int32> bLastMoveReachedGoal() { return { this, "AAIController.bLastMoveReachedGoal" }; }
    BitFieldValue<bool, unsigned __int32> bLastRequestedMoveToLocationWasPlayerCommand() { return { this, "AAIController.bLastRequestedMoveToLocationWasPlayerCommand" }; }
 
    // Functions
 
    UObject * GetUObjectInterfaceAIPerceptionListenerInterface() { return NativeCall<UObject*>(this, "AAIController.GetUObjectInterfaceAIPerceptionListenerInterface"); }
    UField * StaticClass() { return NativeCall<UField*>(this, "AAIController.StaticClass"); }
    void Tick(float DeltaTime) { NativeCall<void, float>(this, "AAIController.Tick", DeltaTime); }
    void PostInitializeComponents() { NativeCall<void>(this, "AAIController.PostInitializeComponents"); }
    void PostRegisterAllComponents() { NativeCall<void>(this, "AAIController.PostRegisterAllComponents"); }
    void Reset() { NativeCall<void>(this, "AAIController.Reset"); }
    void GetPlayerViewPoint(FVector * out_Location, FRotator * out_Rotation) { NativeCall<void, FVector*, FRotator*>(this, "AAIController.GetPlayerViewPoint", out_Location, out_Rotation); }
    void SetFocalPoint(FVector FP, bool bOffsetFromBase, char InPriority) { NativeCall<void, FVector, bool, char>(this, "AAIController.SetFocalPoint", FP, bOffsetFromBase, InPriority); }
    FVector * GetFocalPoint(FVector * result) { return NativeCall<FVector*, FVector*>(this, "AAIController.GetFocalPoint", result); }
    AActor * GetFocusActor() { return NativeCall<AActor*>(this, "AAIController.GetFocusActor"); }
    void SetFocus(AActor * NewFocus, char InPriority) { NativeCall<void, AActor*, char>(this, "AAIController.SetFocus", NewFocus, InPriority); }
    void ClearFocus(char InPriority) { NativeCall<void, char>(this, "AAIController.ClearFocus", InPriority); }
    bool LineOfSightTo(AActor * Other, FVector ViewPoint, bool bAlternateChecks) { return NativeCall<bool, AActor*, FVector, bool>(this, "AAIController.LineOfSightTo", Other, ViewPoint, bAlternateChecks); }
    void UpdateControlRotation(float DeltaTime, bool bUpdatePawn) { NativeCall<void, float, bool>(this, "AAIController.UpdateControlRotation", DeltaTime, bUpdatePawn); }
    void Possess(APawn * InPawn) { NativeCall<void, APawn*>(this, "AAIController.Possess", InPawn); }
    void UnPossess() { NativeCall<void>(this, "AAIController.UnPossess"); }
    EPathFollowingRequestResult::Type MoveToActor(AActor * Goal, float AcceptanceRadius, bool bStopOnOverlap, bool bUsePathfinding, bool bCanStrafe, TSubclassOf<UNavigationQueryFilter> FilterClass) { return NativeCall<EPathFollowingRequestResult::Type, AActor*, float, bool, bool, bool, TSubclassOf<UNavigationQueryFilter>>(this, "AAIController.MoveToActor", Goal, AcceptanceRadius, bStopOnOverlap, bUsePathfinding, bCanStrafe, FilterClass); }
    EPathFollowingRequestResult::Type MoveToLocation(FVector * Dest, float AcceptanceRadius, bool bStopOnOverlap, bool bUsePathfinding, bool bProjectDestinationToNavigation, bool bCanStrafe, TSubclassOf<UNavigationQueryFilter> FilterClass, bool WasPlayerCommand) { return NativeCall<EPathFollowingRequestResult::Type, FVector*, float, bool, bool, bool, bool, TSubclassOf<UNavigationQueryFilter>, bool>(this, "AAIController.MoveToLocation", Dest, AcceptanceRadius, bStopOnOverlap, bUsePathfinding, bProjectDestinationToNavigation, bCanStrafe, FilterClass, WasPlayerCommand); }
    bool HasReached(FVector * TestPoint, float InAcceptanceRadius, bool bExactSpot) { return NativeCall<bool, FVector*, float, bool>(this, "AAIController.HasReached", TestPoint, InAcceptanceRadius, bExactSpot); }
    bool HasReached(AActor * TestGoal, float InAcceptanceRadius, bool bExactSpot) { return NativeCall<bool, AActor*, float, bool>(this, "AAIController.HasReached", TestGoal, InAcceptanceRadius, bExactSpot); }
    bool HasReachedDestination(FVector * CurrentLocation) { return NativeCall<bool, FVector*>(this, "AAIController.HasReachedDestination", CurrentLocation); }
    bool HasReachedCurrentTarget(FVector * CurrentLocation) { return NativeCall<bool, FVector*>(this, "AAIController.HasReachedCurrentTarget", CurrentLocation); }
    bool HasReachedInternal(FVector * Goal, float GoalRadius, float GoalHalfHeight, FVector * AgentLocation, float RadiusThreshold, bool bUseAgentRadius) { return NativeCall<bool, FVector*, float, float, FVector*, float, bool>(this, "AAIController.HasReachedInternal", Goal, GoalRadius, GoalHalfHeight, AgentLocation, RadiusThreshold, bUseAgentRadius); }
    void AbortMove(FString * Reason, FAIRequestID RequestID, bool bResetVelocity, bool bSilent, char MessageFlags) { NativeCall<void, FString*, FAIRequestID, bool, bool, char>(this, "AAIController.AbortMove", Reason, RequestID, bResetVelocity, bSilent, MessageFlags); }
    void UpdatePathSegment() { NativeCall<void>(this, "AAIController.UpdatePathSegment"); }
    void FollowPathSegment(float DeltaTime) { NativeCall<void, float>(this, "AAIController.FollowPathSegment", DeltaTime); }
    void ResetMovement() { NativeCall<void>(this, "AAIController.ResetMovement"); }
    void OnPathFinished(EPathFollowingResult::Type Result) { NativeCall<void, EPathFollowingResult::Type>(this, "AAIController.OnPathFinished", Result); }
    FVector * GetMoveFocus(FVector * result) { return NativeCall<FVector*, FVector*>(this, "AAIController.GetMoveFocus", result); }
    void UpdateMoveFocus() { NativeCall<void>(this, "AAIController.UpdateMoveFocus"); }
    void SetMoveSegment(int SegmentStartIndex) { NativeCall<void, int>(this, "AAIController.SetMoveSegment", SegmentStartIndex); }
    void StopMovement() { NativeCall<void>(this, "AAIController.StopMovement"); }
    void OnMoveCompleted(FAIRequestID RequestID, EPathFollowingResult::Type Result) { NativeCall<void, FAIRequestID, EPathFollowingResult::Type>(this, "AAIController.OnMoveCompleted", RequestID, Result); }
    static void StaticRegisterNativesAAIController() { NativeCall<void>(nullptr, "AAIController.StaticRegisterNativesAAIController"); }
};
 
struct APrimalDinoAIController : AAIController
{
    float& DieIfLeftWaterWanderMinimumWaterHeightMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.DieIfLeftWaterWanderMinimumWaterHeightMultiplier"); }
    float& DieIfLeftWaterReachedRadiusDistanceCheckMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.DieIfLeftWaterReachedRadiusDistanceCheckMultiplier"); }
    float& DieIfLeftWaterTargetUnsubmergedTimeoutField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.DieIfLeftWaterTargetUnsubmergedTimeout"); }
    float& LandDinoMaxWaterTargetDepthCapsuleMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.LandDinoMaxWaterTargetDepthCapsuleMultiplier"); }
    float& ExtraCorpseTargetingRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.ExtraCorpseTargetingRange"); }
    float& FleeFromAttackCoolDownTimeField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.FleeFromAttackCoolDownTime"); }
    float& FleeFromAttackTimeLimitField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.FleeFromAttackTimeLimit"); }
    float& ForceFleeUnderHealthPercentageField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.ForceFleeUnderHealthPercentage"); }
    bool& bFleeOnCriticalHealthField() { return *GetNativePointerField<bool*>(this, "APrimalDinoAIController.bFleeOnCriticalHealth"); }
    float& DieIfLeftWaterTargetingRequiresFreeDepthField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.DieIfLeftWaterTargetingRequiresFreeDepth"); }
    long double& LastBlockadeCheckTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoAIController.LastBlockadeCheckTime"); }
    long double& LastMovingAroundBlockadeTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoAIController.LastMovingAroundBlockadeTime"); }
    float& MovingAroundBlockadeDirectionField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.MovingAroundBlockadeDirection"); }
    FVector& MovingAroundBlockadePointField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoAIController.MovingAroundBlockadePoint"); }
    float& LastBlockadeWidthField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.LastBlockadeWidth"); }
    FVector& LastBlockadeHitNormalField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoAIController.LastBlockadeHitNormal"); }
    FVector& LastBlockadeHitLocationField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoAIController.LastBlockadeHitLocation"); }
    FVector& StartMovingAroundBlockadeLocationField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoAIController.StartMovingAroundBlockadeLocation"); }
    AActor* LastMovingAroundBlockadeActorField() { return *GetNativePointerField<AActor**>(this, "APrimalDinoAIController.LastMovingAroundBlockadeActor"); }
    AActor* ForceTargetActorField() { return *GetNativePointerField<AActor**>(this, "APrimalDinoAIController.ForceTargetActor"); }
    AActor* TargetField() { return *GetNativePointerField<AActor**>(this, "APrimalDinoAIController.Target"); }
    float& AttackDestinationOffsetField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.AttackDestinationOffset"); }
    bool& bUseOverlapTargetCheckField() { return *GetNativePointerField<bool*>(this, "APrimalDinoAIController.bUseOverlapTargetCheck"); }
    bool& bNotifyNeighborsWithoutDamageField() { return *GetNativePointerField<bool*>(this, "APrimalDinoAIController.bNotifyNeighborsWithoutDamage"); }
    bool& bUseBPShouldNotifyNeighborField() { return *GetNativePointerField<bool*>(this, "APrimalDinoAIController.bUseBPShouldNotifyNeighbor"); }
    bool& bUseBPShouldNotifyAnyNeighborField() { return *GetNativePointerField<bool*>(this, "APrimalDinoAIController.bUseBPShouldNotifyAnyNeighbor"); }
    bool& bRequireAbsoluteDamageForNeighborNotificationField() { return *GetNativePointerField<bool*>(this, "APrimalDinoAIController.bRequireAbsoluteDamageForNeighborNotification"); }
    float& AboveDeltaZAttackRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.AboveDeltaZAttackRange"); }
    float& BelowDeltaZAttackRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.BelowDeltaZAttackRange"); }
    float& WildAboveDeltaZTargetingRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.WildAboveDeltaZTargetingRange"); }
    float& WildBelowDeltaZTargetingRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.WildBelowDeltaZTargetingRange"); }
    bool& bWildUseDeltaZTargetingForFlyerPawnOrBigDinoField() { return *GetNativePointerField<bool*>(this, "APrimalDinoAIController.bWildUseDeltaZTargetingForFlyerPawnOrBigDino"); }
    bool& bDontWanderField() { return *GetNativePointerField<bool*>(this, "APrimalDinoAIController.bDontWander"); }
    bool& bOnlyOverlapTargetCorpsesUnlessHasTargetField() { return *GetNativePointerField<bool*>(this, "APrimalDinoAIController.bOnlyOverlapTargetCorpsesUnlessHasTarget"); }
    float& NaturalTargetingRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.NaturalTargetingRange"); }
    float& TamedTargetingRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.TamedTargetingRange"); }
    float& TamedCorpseFoodTargetingRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.TamedCorpseFoodTargetingRange"); }
    float& WanderRandomDistanceAmountField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.WanderRandomDistanceAmount"); }
    float& FlyingWanderFixedDistanceAmountField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.FlyingWanderFixedDistanceAmount"); }
    float& FlyingWanderRandomDistanceAmountField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.FlyingWanderRandomDistanceAmount"); }
    float& MaxFlyingTargetDeltaZField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.MaxFlyingTargetDeltaZ"); }
    float& WanderFlyingZScalerField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.WanderFlyingZScaler"); }
    float& WanderFlyingClampZHeightAboveGroundField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.WanderFlyingClampZHeightAboveGround"); }
    float& WanderFlyingMinZHeightAboveGroundField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.WanderFlyingMinZHeightAboveGround"); }
    float& WanderFixedDistanceAmountField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.WanderFixedDistanceAmount"); }
    bool& bUseAggroField() { return *GetNativePointerField<bool*>(this, "APrimalDinoAIController.bUseAggro"); }
    float& MinAggroValueField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.MinAggroValue"); }
    float& AggroToAddUponRemovingTargetField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.AggroToAddUponRemovingTarget"); }
    float& AggroToAddUponAcquiringTargetField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.AggroToAddUponAcquiringTarget"); }
    float& AggroFactorDecreaseSpeedField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.AggroFactorDecreaseSpeed"); }
    float& AggroFactorDecreaseGracePeriodField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.AggroFactorDecreaseGracePeriod"); }
    float& AggroFactorDamagePercentageMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.AggroFactorDamagePercentageMultiplier"); }
    float& AggroNotifyNeighborsMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.AggroNotifyNeighborsMultiplier"); }
    float& AggroNotifyNeighborsRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.AggroNotifyNeighborsRange"); }
    float& AggroNotifyNeighborsRangeFalloffField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.AggroNotifyNeighborsRangeFalloff"); }
    float& TargetingDistanceReductionFactorLinearField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.TargetingDistanceReductionFactorLinear"); }
    float& TargetingDistanceReductionFactorExponentField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.TargetingDistanceReductionFactorExponent"); }
    float& BeyondTargetingRangeAggroAdditionField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.BeyondTargetingRangeAggroAddition"); }
    float& AggroFactorDesirabilityMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.AggroFactorDesirabilityMultiplier"); }
    float& AttackRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.AttackRange"); }
    float& AttackIntervalField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.AttackInterval"); }
    float& AttackRotationRangeDegreesField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.AttackRotationRangeDegrees"); }
    float& AttackRotationGroundSpeedMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.AttackRotationGroundSpeedMultiplier"); }
    float& RangeTargetWildDinosMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.RangeTargetWildDinosMultiplier"); }
    FRotator& AttackRotationRateField() { return *GetNativePointerField<FRotator*>(this, "APrimalDinoAIController.AttackRotationRate"); }
    bool& bFocusOnTargetDuringAttackField() { return *GetNativePointerField<bool*>(this, "APrimalDinoAIController.bFocusOnTargetDuringAttack"); }
    FVector& FlyingMoveTowardsTargetOffsetField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoAIController.FlyingMoveTowardsTargetOffset"); }
    FVector& CombatFlyingMoveTowardsTargetOffsetField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoAIController.CombatFlyingMoveTowardsTargetOffset"); }
    FVector& FlyingTargetFocalPositionOffsetField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoAIController.FlyingTargetFocalPositionOffset"); }
    float& FlyingReachedDestinationThresholdOffsetField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.FlyingReachedDestinationThresholdOffset"); }
    float& SeekingIntervalCheckToFlyField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.SeekingIntervalCheckToFly"); }
    float& SeekingPercentChanceToFlyField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.SeekingPercentChanceToFly"); }
    float& SeekingIntervalCheckToLandField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.SeekingIntervalCheckToLand"); }
    float& SeekingPercentChanceToLandField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.SeekingPercentChanceToLand"); }
    float& MinimumWanderGroundNormalZField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.MinimumWanderGroundNormalZ"); }
    float& FollowStoppingDistanceField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.FollowStoppingDistance"); }
    bool& bUseOverlapTargetCheckTracesField() { return *GetNativePointerField<bool*>(this, "APrimalDinoAIController.bUseOverlapTargetCheckTraces"); }
    bool& bUseAlternateMovePointField() { return *GetNativePointerField<bool*>(this, "APrimalDinoAIController.bUseAlternateMovePoint"); }
    bool& bTotallyIgnoreWaterTargetsField() { return *GetNativePointerField<bool*>(this, "APrimalDinoAIController.bTotallyIgnoreWaterTargets"); }
    bool& bWaterDinoAllowUnsubmergedTargetsField() { return *GetNativePointerField<bool*>(this, "APrimalDinoAIController.bWaterDinoAllowUnsubmergedTargets"); }
    FVector& LastCheckAttackRangePawnLocationField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoAIController.LastCheckAttackRangePawnLocation"); }
    FVector& LastCheckAttackRangeClosestPointField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoAIController.LastCheckAttackRangeClosestPoint"); }
    FVector& LastCheckAttackRangeTargetLocationField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoAIController.LastCheckAttackRangeTargetLocation"); }
    AActor* LastCheckAttackRangeTargetField() { return *GetNativePointerField<AActor**>(this, "APrimalDinoAIController.LastCheckAttackRangeTarget"); }
    bool& HasAttackPriorityField() { return *GetNativePointerField<bool*>(this, "APrimalDinoAIController.HasAttackPriority"); }
    TArray<float>& TamedAITargetingRangeMultipliersField() { return *GetNativePointerField<TArray<float>*>(this, "APrimalDinoAIController.TamedAITargetingRangeMultipliers"); }
    float& MateBoostAggroNotifyNeighborsMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.MateBoostAggroNotifyNeighborsMultiplier"); }
    TArray<TSubclassOf<APrimalDinoCharacter>>& AggroNotifyNeighborsClassesField() { return *GetNativePointerField<TArray<TSubclassOf<APrimalDinoCharacter>>*>(this, "APrimalDinoAIController.AggroNotifyNeighborsClasses"); }
    float& MoveAroundBlockadeAdditionalWidthField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.MoveAroundBlockadeAdditionalWidth"); }
    float& MoveAroundObjectMaxVelocityField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.MoveAroundObjectMaxVelocity"); }
    float& ForcedAggroTimeCounterField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.ForcedAggroTimeCounter"); }
    float& TamedMaxFollowDistanceField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.TamedMaxFollowDistance"); }
    float& BaseStructureTargetingDesireField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.BaseStructureTargetingDesire"); }
    float& LandDinoMaxFlyerTargetDeltaZField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.LandDinoMaxFlyerTargetDeltaZ"); }
    float& NaturalMaxDepthZField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.NaturalMaxDepthZ"); }
    TWeakObjectPtr<AActor>& ForcedAttackTargetField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "APrimalDinoAIController.ForcedAttackTarget"); }
    int& ForcedAttackEnemyTeamField() { return *GetNativePointerField<int*>(this, "APrimalDinoAIController.ForcedAttackEnemyTeam"); }
    long double& LastForcedAttackEnemyTeamTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoAIController.LastForcedAttackEnemyTeamTime"); }
    int& LastCharacterTargetTeamField() { return *GetNativePointerField<int*>(this, "APrimalDinoAIController.LastCharacterTargetTeam"); }
    float& ForcedFleeDurationField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.ForcedFleeDuration"); }
    float& MinAttackIntervalForFleeingField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.MinAttackIntervalForFleeing"); }
    float& MinLocChangeIntervalForFleeingField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.MinLocChangeIntervalForFleeing"); }
    float& PercentageTorporForFleeingField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.PercentageTorporForFleeing"); }
    float& DamagedForceAggroIntervalField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.DamagedForceAggroInterval"); }
    long double& ForceAggroUntilTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoAIController.ForceAggroUntilTime"); }
    long double& LastExecutedAttackTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoAIController.LastExecutedAttackTime"); }
    long double& LastForcedFleeTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoAIController.LastForcedFleeTime"); }
    long double& LastFleeLocCheckTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoAIController.LastFleeLocCheckTime"); }
    FVector& LastFleeLocCheckField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoAIController.LastFleeLocCheck"); }
    int& NumAlliesToAttackField() { return *GetNativePointerField<int*>(this, "APrimalDinoAIController.NumAlliesToAttack"); }
    float& FindLandingPositionZOffsetField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.FindLandingPositionZOffset"); }
    float& TamedFollowAcceptanceRadiusOffsetField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.TamedFollowAcceptanceRadiusOffset"); }
    float& TamedFollowAcceptanceHeightOffsetField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.TamedFollowAcceptanceHeightOffset"); }
    float& AIFlightMaxLandingZDistanceField() { return *GetNativePointerField<float*>(this, "APrimalDinoAIController.AIFlightMaxLandingZDistance"); }
    long double& ForcedMoveToUntilTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoAIController.ForcedMoveToUntilTime"); }
    long double& LastHadAggroEntriesTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoAIController.LastHadAggroEntriesTime"); }
    TArray<TSubclassOf<AActor>>& WildTargetingDesireMultiplierClassesField() { return *GetNativePointerField<TArray<TSubclassOf<AActor>>*>(this, "APrimalDinoAIController.WildTargetingDesireMultiplierClasses"); }
    TArray<float>& WildTargetingDesireMultiplierValuesField() { return *GetNativePointerField<TArray<float>*>(this, "APrimalDinoAIController.WildTargetingDesireMultiplierValues"); }
    TArray<TSubclassOf<AActor>>& TamedTargetingDesireMultiplierClassesField() { return *GetNativePointerField<TArray<TSubclassOf<AActor>>*>(this, "APrimalDinoAIController.TamedTargetingDesireMultiplierClasses"); }
    TArray<float>& TamedTargetingDesireMultiplierValuesField() { return *GetNativePointerField<TArray<float>*>(this, "APrimalDinoAIController.TamedTargetingDesireMultiplierValues"); }
 
    // Bit fields
 
    BitFieldValue<bool, unsigned __int32> bForcedAggro() { return { this, "APrimalDinoAIController.bForcedAggro" }; }
    BitFieldValue<bool, unsigned __int32> bIgnoreMoveAroundBlockade() { return { this, "APrimalDinoAIController.bIgnoreMoveAroundBlockade" }; }
    BitFieldValue<bool, unsigned __int32> bFlyingUseMoveAroundBlockade() { return { this, "APrimalDinoAIController.bFlyingUseMoveAroundBlockade" }; }
    BitFieldValue<bool, unsigned __int32> bUseGeometryInsteadOfStationObjForFreeDepthTest() { return { this, "APrimalDinoAIController.bUseGeometryInsteadOfStationObjForFreeDepthTest" }; }
    BitFieldValue<bool, unsigned __int32> bNotifyBPTargetSet() { return { this, "APrimalDinoAIController.bNotifyBPTargetSet" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPSetupFindTarget() { return { this, "APrimalDinoAIController.bUseBPSetupFindTarget" }; }
    BitFieldValue<bool, unsigned __int32> bNotAllowedToFindTargets() { return { this, "APrimalDinoAIController.bNotAllowedToFindTargets" }; }
    BitFieldValue<bool, unsigned __int32> bAllowForceFleeToSameTargetingTeam() { return { this, "APrimalDinoAIController.bAllowForceFleeToSameTargetingTeam" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPUpdateBestTarget() { return { this, "APrimalDinoAIController.bUseBPUpdateBestTarget" }; }
    BitFieldValue<bool, unsigned __int32> bTargetChanged() { return { this, "APrimalDinoAIController.bTargetChanged" }; }
    BitFieldValue<bool, unsigned __int32> bAttackForcesRunning() { return { this, "APrimalDinoAIController.bAttackForcesRunning" }; }
    BitFieldValue<bool, unsigned __int32> bUseFlyingTargetOffsets() { return { this, "APrimalDinoAIController.bUseFlyingTargetOffsets" }; }
    BitFieldValue<bool, unsigned __int32> bRidingDinoTargetPlayer() { return { this, "APrimalDinoAIController.bRidingDinoTargetPlayer" }; }
    BitFieldValue<bool, unsigned __int32> bRidingPlayerTargetDino() { return { this, "APrimalDinoAIController.bRidingPlayerTargetDino" }; }
    BitFieldValue<bool, unsigned __int32> bIgnoreWaterOrAmphibiousTargets() { return { this, "APrimalDinoAIController.bIgnoreWaterOrAmphibiousTargets" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPTargetingDesire() { return { this, "APrimalDinoAIController.bUseBPTargetingDesire" }; }
    BitFieldValue<bool, unsigned __int32> bDisableForceFlee() { return { this, "APrimalDinoAIController.bDisableForceFlee" }; }
    BitFieldValue<bool, unsigned __int32> bUseCombatMoveTowardsTargetOffset() { return { this, "APrimalDinoAIController.bUseCombatMoveTowardsTargetOffset" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOverrideIgnoredByWildDino() { return { this, "APrimalDinoAIController.bUseBPOverrideIgnoredByWildDino" }; }
    BitFieldValue<bool, unsigned __int32> bCanUseAttackStateOnTargetChange() { return { this, "APrimalDinoAIController.bCanUseAttackStateOnTargetChange" }; }
    BitFieldValue<bool, unsigned __int32> bModifiedWanderRadius() { return { this, "APrimalDinoAIController.bModifiedWanderRadius" }; }
    BitFieldValue<bool, unsigned __int32> bForceOnlyTargetingPlayerOrTamed() { return { this, "APrimalDinoAIController.bForceOnlyTargetingPlayerOrTamed" }; }
    BitFieldValue<bool, unsigned __int32> bForceTargetingAllStructures() { return { this, "APrimalDinoAIController.bForceTargetingAllStructures" }; }
    BitFieldValue<bool, unsigned __int32> bForceTargetDinoRider() { return { this, "APrimalDinoAIController.bForceTargetDinoRider" }; }
    BitFieldValue<bool, unsigned __int32> bFlyerAllowWaterTargeting() { return { this, "APrimalDinoAIController.bFlyerAllowWaterTargeting" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPForceTargetDinoRider() { return { this, "APrimalDinoAIController.bUseBPForceTargetDinoRider" }; }
    BitFieldValue<bool, unsigned __int32> bAlwaysStartledWhenAggroedByNeighbor() { return { this, "APrimalDinoAIController.bAlwaysStartledWhenAggroedByNeighbor" }; }
    BitFieldValue<bool, unsigned __int32> bForceOnlyTargetingPlayers() { return { this, "APrimalDinoAIController.bForceOnlyTargetingPlayers" }; }
    BitFieldValue<bool, unsigned __int32> bIsMissionDino() { return { this, "APrimalDinoAIController.bIsMissionDino" }; }
    BitFieldValue<bool, unsigned __int32> bUseImprovedAggroFalloffBehavior() { return { this, "APrimalDinoAIController.bUseImprovedAggroFalloffBehavior" }; }
    BitFieldValue<bool, unsigned __int32> bUseBP_TamedOverrideHorizontalLandingRange() { return { this, "APrimalDinoAIController.bUseBP_TamedOverrideHorizontalLandingRange" }; }
    BitFieldValue<bool, unsigned __int32> bFlyerWanderDefaultToOrigin() { return { this, "APrimalDinoAIController.bFlyerWanderDefaultToOrigin" }; }
    BitFieldValue<bool, unsigned __int32> bCheckBuffTargetingDesireOverride() { return { this, "APrimalDinoAIController.bCheckBuffTargetingDesireOverride" }; }
 
    // Functions
 
    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "APrimalDinoAIController.StaticClass"); }
    void BeginPlay() { NativeCall<void>(this, "APrimalDinoAIController.BeginPlay"); }
    void ForceLand() { NativeCall<void>(this, "APrimalDinoAIController.ForceLand"); }
    FVector* GetRandomWanderDestination(FVector* result, FVector LocOverride, float RandomOffsetMultiplier, bool bUseRandomNegativeXDir, bool bOrientRandOffsetByRotation, FRotator OrientRandOffsetByRotation) { return NativeCall<FVector*, FVector*, FVector, float, bool, bool, FRotator>(this, "APrimalDinoAIController.GetRandomWanderDestination", result, LocOverride, RandomOffsetMultiplier, bUseRandomNegativeXDir, bOrientRandOffsetByRotation, OrientRandOffsetByRotation); }
    static FVector* StaticGetRandomWanderDestination(FVector* result, APrimalDinoCharacter* TargetCharacter, APrimalDinoAIController* TargetAIController, FVector LocOverride, float RandomOffsetMultiplier, bool bUseRandomNegativeXDir, bool bOrientRandOffsetByRotation, FRotator OrientRandOffsetByRotation, float GroundCheckSpreadOverride) { return NativeCall<FVector*, FVector*, APrimalDinoCharacter*, APrimalDinoAIController*, FVector, float, bool, bool, FRotator, float>(nullptr, "APrimalDinoAIController.StaticGetRandomWanderDestination", result, TargetCharacter, TargetAIController, LocOverride, RandomOffsetMultiplier, bUseRandomNegativeXDir, bOrientRandOffsetByRotation, OrientRandOffsetByRotation, GroundCheckSpreadOverride); }
    void Unstasis() { NativeCall<void>(this, "APrimalDinoAIController.Unstasis"); }
    AActor* GetCorpseFoodTarget() { return NativeCall<AActor*>(this, "APrimalDinoAIController.GetCorpseFoodTarget"); }
    AActor* FindTarget(bool bDontSet) { return NativeCall<AActor*, bool>(this, "APrimalDinoAIController.FindTarget", bDontSet); }
    float GetTargetingDesire(AActor* InTarget) { return NativeCall<float, AActor*>(this, "APrimalDinoAIController.GetTargetingDesire", InTarget); }
    void SetTarget(AActor* InTarget, bool bDontAddAggro, bool bOverlapFoundTarget) { NativeCall<void, AActor*, bool, bool>(this, "APrimalDinoAIController.SetTarget", InTarget, bDontAddAggro, bOverlapFoundTarget); }
    void AddToAggro(AActor* Attacker, float DamagePercent, bool bNotifyNeighbors, bool SetValue, bool bIsFromDamage, bool skipTeamCheck) { NativeCall<void, AActor*, float, bool, bool, bool, bool>(this, "APrimalDinoAIController.AddToAggro", Attacker, DamagePercent, bNotifyNeighbors, SetValue, bIsFromDamage, skipTeamCheck); }
    AActor* FindNewTarget(bool bDontSet) { return NativeCall<AActor*, bool>(this, "APrimalDinoAIController.FindNewTarget", bDontSet); }
    AActor* GetTarget() { return NativeCall<AActor*>(this, "APrimalDinoAIController.GetTarget"); }
    void UpdateAggro() { NativeCall<void>(this, "APrimalDinoAIController.UpdateAggro"); }
    bool IsWithinAttackRange(AActor* Other, bool bForceUseLastAttackIndex) { return NativeCall<bool, AActor*, bool>(this, "APrimalDinoAIController.IsWithinAttackRange", Other, bForceUseLastAttackIndex); }
    float GetAttackRange() { return NativeCall<float>(this, "APrimalDinoAIController.GetAttackRange"); }
    float GetMinAttackRange() { return NativeCall<float>(this, "APrimalDinoAIController.GetMinAttackRange"); }
    float GetAttackInterval() { return NativeCall<float>(this, "APrimalDinoAIController.GetAttackInterval"); }
    float GetAttackRotationRangeDegrees() { return NativeCall<float>(this, "APrimalDinoAIController.GetAttackRotationRangeDegrees"); }
    float GetAttackRotationGroundSpeedMultiplier() { return NativeCall<float>(this, "APrimalDinoAIController.GetAttackRotationGroundSpeedMultiplier"); }
    FRotator* GetAttackRotationRate(FRotator* result) { return NativeCall<FRotator*, FRotator*>(this, "APrimalDinoAIController.GetAttackRotationRate", result); }
    FVector* GetWanderAroundActorDestination(FVector* result, APrimalDinoCharacter* dinoCharacter, FVector originalDestination) { return NativeCall<FVector*, FVector*, APrimalDinoCharacter*, FVector>(this, "APrimalDinoAIController.GetWanderAroundActorDestination", result, dinoCharacter, originalDestination); }
    char GetCurrentAttackIndex() { return NativeCall<char>(this, "APrimalDinoAIController.GetCurrentAttackIndex"); }
    bool IsWithinAttackRangeAndCalculateBestAttack(AActor* Other, bool* bAttackChanged) { return NativeCall<bool, AActor*, bool*>(this, "APrimalDinoAIController.IsWithinAttackRangeAndCalculateBestAttack", Other, bAttackChanged); }
    bool CalculateAndSetWonderingAIState(bool* StateChanged) { return NativeCall<bool, bool*>(this, "APrimalDinoAIController.CalculateAndSetWonderingAIState", StateChanged); }
    APrimalDinoCharacter* GetControlledDino() { return NativeCall<APrimalDinoCharacter*>(this, "APrimalDinoAIController.GetControlledDino"); }
    float GetAggroDesirability(AActor* InTarget) { return NativeCall<float, AActor*>(this, "APrimalDinoAIController.GetAggroDesirability", InTarget); }
    void NotifyTakeDamage(float Damage, FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { NativeCall<void, float, FDamageEvent*, AController*, AActor*>(this, "APrimalDinoAIController.NotifyTakeDamage", Damage, DamageEvent, EventInstigator, DamageCauser); }
    bool CheckMoveAroundBlockadePoint(FVector moveToPoint) { return NativeCall<bool, FVector>(this, "APrimalDinoAIController.CheckMoveAroundBlockadePoint", moveToPoint); }
    bool MoveAroundBlockade(FVector PreBumpLocation, AActor* BlockadeActor, UPrimitiveComponent* OtherComp, float BlockadeWidth, FVector HitNormal, FVector HitLocation, bool SkipBlockingCheck) { return NativeCall<bool, FVector, AActor*, UPrimitiveComponent*, float, FVector, FVector, bool>(this, "APrimalDinoAIController.MoveAroundBlockade", PreBumpLocation, BlockadeActor, OtherComp, BlockadeWidth, HitNormal, HitLocation, SkipBlockingCheck); }
    void NotifyBump(FVector PreBumpLocation, AActor* Other, UPrimitiveComponent* OtherComp, FVector* HitNormal, FVector* HitLocation) { NativeCall<void, FVector, AActor*, UPrimitiveComponent*, FVector*, FVector*>(this, "APrimalDinoAIController.NotifyBump", PreBumpLocation, Other, OtherComp, HitNormal, HitLocation); }
    void RecoverMovement() { NativeCall<void>(this, "APrimalDinoAIController.RecoverMovement"); }
    void PlayStartledAnim() { NativeCall<void>(this, "APrimalDinoAIController.PlayStartledAnim"); }
    void Destroyed() { NativeCall<void>(this, "APrimalDinoAIController.Destroyed"); }
    bool CanLand() { return NativeCall<bool>(this, "APrimalDinoAIController.CanLand"); }
    FVector* GetLandingLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APrimalDinoAIController.GetLandingLocation", result); }
    void SetAttackRotationRate() { NativeCall<void>(this, "APrimalDinoAIController.SetAttackRotationRate"); }
    void ResetRotationUseAcceleration() { NativeCall<void>(this, "APrimalDinoAIController.ResetRotationUseAcceleration"); }
    void ResetAccelerationFollowsRotation() { NativeCall<void>(this, "APrimalDinoAIController.ResetAccelerationFollowsRotation"); }
    void ResetRotationRate() { NativeCall<void>(this, "APrimalDinoAIController.ResetRotationRate"); }
    void SetAttackGroundSpeed() { NativeCall<void>(this, "APrimalDinoAIController.SetAttackGroundSpeed"); }
    void ResetGroundSpeed() { NativeCall<void>(this, "APrimalDinoAIController.ResetGroundSpeed"); }
    void AvoidOutOfWater() { NativeCall<void>(this, "APrimalDinoAIController.AvoidOutOfWater"); }
    void AvoidGenericToPoint(FVector TargetDestination) { NativeCall<void, FVector>(this, "APrimalDinoAIController.AvoidGenericToPoint", TargetDestination); }
    bool UseLowQualityBehaviorTreeTick() { return NativeCall<bool>(this, "APrimalDinoAIController.UseLowQualityBehaviorTreeTick"); }
    void Possess(APawn* InPawn) { NativeCall<void, APawn*>(this, "APrimalDinoAIController.Possess", InPawn); }
    void ClearAggroEntries() { NativeCall<void>(this, "APrimalDinoAIController.ClearAggroEntries"); }
    bool ShouldForceFlee() { return NativeCall<bool>(this, "APrimalDinoAIController.ShouldForceFlee"); }
    int GetAggroEntriesCount() { return NativeCall<int>(this, "APrimalDinoAIController.GetAggroEntriesCount"); }
    AActor* GetAggroEntriesAttackerAtIndex(int Index) { return NativeCall<AActor*, int>(this, "APrimalDinoAIController.GetAggroEntriesAttackerAtIndex", Index); }
    bool GetAggroEntry(int Index, AActor** OutAttacker, float* OutAggroFactor, long double* OutLastAggroHitTime) { return NativeCall<bool, int, AActor**, float*, long double*>(this, "APrimalDinoAIController.GetAggroEntry", Index, OutAttacker, OutAggroFactor, OutLastAggroHitTime); }
    void SetHasAttackPriority(bool Value) { NativeCall<void, bool>(this, "APrimalDinoAIController.SetHasAttackPriority", Value); }
    bool ShouldForceRunWhenAttacking() { return NativeCall<bool>(this, "APrimalDinoAIController.ShouldForceRunWhenAttacking"); }
    APawn* GetControllerPawn() { return NativeCall<APawn*>(this, "APrimalDinoAIController.GetControllerPawn"); }
    float GetAcceptanceHeightOffset() { return NativeCall<float>(this, "APrimalDinoAIController.GetAcceptanceHeightOffset"); }
    float GetAcceptanceRadiusOffset() { return NativeCall<float>(this, "APrimalDinoAIController.GetAcceptanceRadiusOffset"); }
    void OnMoveCompleted(FAIRequestID RequestID, EPathFollowingResult::Type Result) { NativeCall<void, FAIRequestID, EPathFollowingResult::Type>(this, "APrimalDinoAIController.OnMoveCompleted", RequestID, Result); }
    void StopBrainComponent(FString reason) { NativeCall<void, FString>(this, "APrimalDinoAIController.StopBrainComponent", reason); }
    void RestartBrainComponent() { NativeCall<void>(this, "APrimalDinoAIController.RestartBrainComponent"); }
    void PauseBrainComponent(FString reason) { NativeCall<void, FString>(this, "APrimalDinoAIController.PauseBrainComponent", reason); }
    void ResumeBrainComponent(FString reason) { NativeCall<void, FString>(this, "APrimalDinoAIController.ResumeBrainComponent", reason); }
    bool IsLogicPaused() { return NativeCall<bool>(this, "APrimalDinoAIController.IsLogicPaused"); }
    FString* GetDebugInfoString(FString* result) { return NativeCall<FString*, FString*>(this, "APrimalDinoAIController.GetDebugInfoString", result); }
    float GetAggroNotifyNeighborsRange_Implementation() { return NativeCall<float>(this, "APrimalDinoAIController.GetAggroNotifyNeighborsRange_Implementation"); }
    bool IsForceTargetDinoRider(AShooterCharacter* playerTarget) { return NativeCall<bool, AShooterCharacter*>(this, "APrimalDinoAIController.IsForceTargetDinoRider", playerTarget); }
    static void StaticRegisterNativesAPrimalDinoAIController() { NativeCall<void>(nullptr, "APrimalDinoAIController.StaticRegisterNativesAPrimalDinoAIController"); }
    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "APrimalDinoAIController.GetPrivateStaticClass", Package); }
    FVector2D* BP_TamedOverrideHorizontalLandingRange(FVector2D* result) { return NativeCall<FVector2D*, FVector2D*>(this, "APrimalDinoAIController.BP_TamedOverrideHorizontalLandingRange", result); }
    bool BPForceTargetDinoRider(AShooterCharacter* playerTarget) { return NativeCall<bool, AShooterCharacter*>(this, "APrimalDinoAIController.BPForceTargetDinoRider", playerTarget); }
    float BPGetTargetingDesire(AActor* ForTarget, float ForTargetingDesireValue) { return NativeCall<float, AActor*, float>(this, "APrimalDinoAIController.BPGetTargetingDesire", ForTarget, ForTargetingDesireValue); }
    void BPNotifyTargetSet() { NativeCall<void>(this, "APrimalDinoAIController.BPNotifyTargetSet"); }
    void BPOnFleeEvent() { NativeCall<void>(this, "APrimalDinoAIController.BPOnFleeEvent"); }
    bool BPOverrideIgnoredByWildDino(AActor* wildDinoToIgnore) { return NativeCall<bool, AActor*>(this, "APrimalDinoAIController.BPOverrideIgnoredByWildDino", wildDinoToIgnore); }
    void BPSetupFindTarget() { NativeCall<void>(this, "APrimalDinoAIController.BPSetupFindTarget"); }
    bool BPShouldNotifyAnyNeighbor(APrimalDinoCharacter* neighbor) { return NativeCall<bool, APrimalDinoCharacter*>(this, "APrimalDinoAIController.BPShouldNotifyAnyNeighbor", neighbor); }
    bool BPShouldNotifyNeighbor(APrimalDinoCharacter* neighbor) { return NativeCall<bool, APrimalDinoCharacter*>(this, "APrimalDinoAIController.BPShouldNotifyNeighbor", neighbor); }
    AActor* BPUpdateBestTarget(AActor* bestTarget, bool dontSetIn, bool* dontSetOut) { return NativeCall<AActor*, AActor*, bool, bool*>(this, "APrimalDinoAIController.BPUpdateBestTarget", bestTarget, dontSetIn, dontSetOut); }
    bool CalculateAndSetWonderingAIStateEvent(bool StateChanged) { return NativeCall<bool, bool>(this, "APrimalDinoAIController.CalculateAndSetWonderingAIStateEvent", StateChanged); }
    void ChangedAITarget() { NativeCall<void>(this, "APrimalDinoAIController.ChangedAITarget"); }
    float GetAggroNotifyNeighborsRange() { return NativeCall<float>(this, "APrimalDinoAIController.GetAggroNotifyNeighborsRange"); }
    void OnLosingTargetEvent() { NativeCall<void>(this, "APrimalDinoAIController.OnLosingTargetEvent"); }
};
 
struct ADroppedItem : AActor
{
    FItemNetInfo & MyItemInfoField() { return *GetNativePointerField<FItemNetInfo*>(this, "ADroppedItem.MyItemInfo"); }
    UPrimalItem * MyItemField() { return *GetNativePointerField<UPrimalItem**>(this, "ADroppedItem.MyItem"); }
    int& AssignedToTribeIDField() { return *GetNativePointerField<int*>(this, "ADroppedItem.AssignedToTribeID"); }
    float& ImpulseMagnitudeField() { return *GetNativePointerField<float*>(this, "ADroppedItem.ImpulseMagnitude"); }
    float& ForceSleepTimerField() { return *GetNativePointerField<float*>(this, "ADroppedItem.ForceSleepTimer"); }
    FVector & DroppedItemScaleField() { return *GetNativePointerField<FVector*>(this, "ADroppedItem.DroppedItemScale"); }
    FVector2D & OverlayTooltipPaddingField() { return *GetNativePointerField<FVector2D*>(this, "ADroppedItem.OverlayTooltipPadding"); }
    FVector2D & OverlayTooltipScaleField() { return *GetNativePointerField<FVector2D*>(this, "ADroppedItem.OverlayTooltipScale"); }
    FString & DroppedByNameField() { return *GetNativePointerField<FString*>(this, "ADroppedItem.DroppedByName"); }
    unsigned __int64& DroppedByPlayerIDField() { return *GetNativePointerField<unsigned __int64*>(this, "ADroppedItem.DroppedByPlayerID"); }
    long double& DroppedItemDestructionTimeField() { return *GetNativePointerField<long double*>(this, "ADroppedItem.DroppedItemDestructionTime"); }
    FVector & DroppedItemInterpTargetField() { return *GetNativePointerField<FVector*>(this, "ADroppedItem.DroppedItemInterpTarget"); }
    bool& bClientDisablePhysicsField() { return *GetNativePointerField<bool*>(this, "ADroppedItem.bClientDisablePhysics"); }
    UStaticMesh * NetDroppedMeshOverrideField() { return *GetNativePointerField<UStaticMesh**>(this, "ADroppedItem.NetDroppedMeshOverride"); }
    UMaterialInterface * NetDroppedMeshMaterialOverrideField() { return *GetNativePointerField<UMaterialInterface**>(this, "ADroppedItem.NetDroppedMeshMaterialOverride"); }
    FVector & NetDroppedMeshOverrideScale3DField() { return *GetNativePointerField<FVector*>(this, "ADroppedItem.NetDroppedMeshOverrideScale3D"); }
    float& MaxPickUpDistanceField() { return *GetNativePointerField<float*>(this, "ADroppedItem.MaxPickUpDistance"); }
    float& PrevLinearDampingField() { return *GetNativePointerField<float*>(this, "ADroppedItem.PrevLinearDamping"); }
    float& PrevAngularDampingField() { return *GetNativePointerField<float*>(this, "ADroppedItem.PrevAngularDamping"); }
    long double& SpawnDropSoundTimeField() { return *GetNativePointerField<long double*>(this, "ADroppedItem.SpawnDropSoundTime"); }
    FVector & PreviousLocationField() { return *GetNativePointerField<FVector*>(this, "ADroppedItem.PreviousLocation"); }
    TWeakObjectPtr<AActor> & DroppedByActorField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "ADroppedItem.DroppedByActor"); }
    FVector & PreviousStuckLocationField() { return *GetNativePointerField<FVector*>(this, "ADroppedItem.PreviousStuckLocation"); }
    float& LocationStuckTimerField() { return *GetNativePointerField<float*>(this, "ADroppedItem.LocationStuckTimer"); }
    long double& PhysicsKeepAliveUntilTimeField() { return *GetNativePointerField<long double*>(this, "ADroppedItem.PhysicsKeepAliveUntilTime"); }
    float& FreezePhysicsAfterTimeField() { return *GetNativePointerField<float*>(this, "ADroppedItem.FreezePhysicsAfterTime"); }
    float& PickupAllRangeField() { return *GetNativePointerField<float*>(this, "ADroppedItem.PickupAllRange"); }
    float& DroppedLifeSpanOverrideField() { return *GetNativePointerField<float*>(this, "ADroppedItem.DroppedLifeSpanOverride"); }
 
    // Bit fields
 
    BitFieldValue<bool, unsigned __int32> bApplyImpulseOnSpawn() { return { this, "ADroppedItem.bApplyImpulseOnSpawn" }; }
    BitFieldValue<bool, unsigned __int32> bDestroyOnStasis() { return { this, "ADroppedItem.bDestroyOnStasis" }; }
    BitFieldValue<bool, unsigned __int32> bUseCollisionTrace() { return { this, "ADroppedItem.bUseCollisionTrace" }; }
    BitFieldValue<bool, unsigned __int32> bPreventPickup() { return { this, "ADroppedItem.bPreventPickup" }; }
    BitFieldValue<bool, unsigned __int32> bDestroyOutOfWater() { return { this, "ADroppedItem.bDestroyOutOfWater" }; }
    BitFieldValue<bool, unsigned __int32> bUseClientDroppedItemPhysics() { return { this, "ADroppedItem.bUseClientDroppedItemPhysics" }; }
    BitFieldValue<bool, unsigned __int32> bIsUnderwater() { return { this, "ADroppedItem.bIsUnderwater" }; }
    BitFieldValue<bool, unsigned __int32> bNotifyPreviousOwnerOfPickup() { return { this, "ADroppedItem.bNotifyPreviousOwnerOfPickup" }; }
    BitFieldValue<bool, unsigned __int32> bAssignedToTribePickupOnly() { return { this, "ADroppedItem.bAssignedToTribePickupOnly" }; }
    BitFieldValue<bool, unsigned __int32> bLowQuality() { return { this, "ADroppedItem.bLowQuality" }; }
 
    // Functions
 
    void Tick(float DeltaSeconds) { NativeCall<void, float>(this, "ADroppedItem.Tick", DeltaSeconds); }
    void LoadedFromSaveGame() { NativeCall<void>(this, "ADroppedItem.LoadedFromSaveGame"); }
    void Stasis() { NativeCall<void>(this, "ADroppedItem.Stasis"); }
    float GetDroppedItemLifeTime() { return NativeCall<float>(this, "ADroppedItem.GetDroppedItemLifeTime"); }
    bool TryMultiUse(APlayerController * ForPC, int UseIndex) { return NativeCall<bool, APlayerController*, int>(this, "ADroppedItem.TryMultiUse", ForPC, UseIndex); }
    void BeginPlay() { NativeCall<void>(this, "ADroppedItem.BeginPlay"); }
    void SetupDroppedItemLifeSpan() { NativeCall<void>(this, "ADroppedItem.SetupDroppedItemLifeSpan"); }
    void PostNetReceiveLocationAndRotation() { NativeCall<void>(this, "ADroppedItem.PostNetReceiveLocationAndRotation"); }
    void FreezePhysics() { NativeCall<void>(this, "ADroppedItem.FreezePhysics"); }
    void DrawHUD(AShooterHUD * HUD) { NativeCall<void, AShooterHUD*>(this, "ADroppedItem.DrawHUD", HUD); }
    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty> * OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "ADroppedItem.GetLifetimeReplicatedProps", OutLifetimeProps); }
    void ForceSleep() { NativeCall<void>(this, "ADroppedItem.ForceSleep"); }
    void SetupVisuals() { NativeCall<void>(this, "ADroppedItem.SetupVisuals"); }
    void PreInitializeComponents() { NativeCall<void>(this, "ADroppedItem.PreInitializeComponents"); }
    void KeepPhysicsActiveForDuration(float Duration) { NativeCall<void, float>(this, "ADroppedItem.KeepPhysicsActiveForDuration", Duration); }
    static UClass * StaticClass() { return NativeCall<UClass*>(nullptr, "ADroppedItem.StaticClass"); }
    static void StaticRegisterNativesADroppedItem() { NativeCall<void>(nullptr, "ADroppedItem.StaticRegisterNativesADroppedItem"); }
    static UClass * GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "ADroppedItem.GetPrivateStaticClass", Package); }
    bool IsAllowedToPickupItem(APlayerController * PC) { return NativeCall<bool, APlayerController*>(this, "ADroppedItem.IsAllowedToPickupItem", PC); }
};
 
struct ADroppedItemEgg : ADroppedItem
{
    float& IndoorsHypoThermalInsulationField() { return *GetNativePointerField<float*>(this, "ADroppedItemEgg.IndoorsHypoThermalInsulation"); }
    float& IndoorsHyperThermalInsulationField() { return *GetNativePointerField<float*>(this, "ADroppedItemEgg.IndoorsHyperThermalInsulation"); }
    float& EggThermalInsulationTemperatureMultiplierField() { return *GetNativePointerField<float*>(this, "ADroppedItemEgg.EggThermalInsulationTemperatureMultiplier"); }
    double& LastInsulationCalcTimeField() { return *GetNativePointerField<double*>(this, "ADroppedItemEgg.LastInsulationCalcTime"); }
    float& HyperThermalInsulationField() { return *GetNativePointerField<float*>(this, "ADroppedItemEgg.HyperThermalInsulation"); }
    float& HypoThermalInsulationField() { return *GetNativePointerField<float*>(this, "ADroppedItemEgg.HypoThermalInsulation"); }
 
    // Bit fields
 
    BitFieldValue<bool, unsigned __int32> bIsEggTooHot() { return { this, "ADroppedItemEgg.bIsEggTooHot" }; }
    BitFieldValue<bool, unsigned __int32> bIsEggTooCold() { return { this, "ADroppedItemEgg.bIsEggTooCold" }; }
 
    // Functions 
 
    void UpdateEgg(float DeltaSeconds) { NativeCall<void, float>(this, "ADroppedItemEgg.UpdateEgg", DeltaSeconds); }
    void Tick(float DeltaTime) { NativeCall<void, float>(this, "ADroppedItemEgg.Tick", DeltaTime); }
    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "ADroppedItemEgg.StaticClass"); }
    void Stasis() { NativeCall<void>(this, "ADroppedItemEgg.Stasis"); }
    void NetSpawnDinoEmitter() { NativeCall<void>(this, "ADroppedItemEgg.NetSpawnDinoEmitter"); }
    void NetSpawnDinoEmitter_Implementation() { NativeCall<void>(this, "ADroppedItemEgg.NetSpawnDinoEmitter_Implementation"); }
    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "ADroppedItemEgg.GetPrivateStaticClass"); }
    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "ADroppedItemEgg.GetLifetimeReplicatedProps", OutLifetimeProps); }
    void CalcInsulation() { NativeCall<void>(this, "ADroppedItemEgg.CalcInsulation"); }
    void BeginPlay() { NativeCall<void>(this, "ADroppedItemEgg.BeginPlay"); }
};
 
struct AMatineeActor : AActor
{
    FName& MatineeControllerNameField() { return *GetNativePointerField<FName*>(this, "AMatineeActor.MatineeControllerName"); }
    float& PlayRateField() { return *GetNativePointerField<float*>(this, "AMatineeActor.PlayRate"); }
    float& ForceStartPositionField() { return *GetNativePointerField<float*>(this, "AMatineeActor.ForceStartPosition"); }
    int& MatineeManagerPriorityField() { return *GetNativePointerField<int*>(this, "AMatineeActor.MatineeManagerPriority"); }
    int& PreferredSplitScreenNumField() { return *GetNativePointerField<int*>(this, "AMatineeActor.PreferredSplitScreenNum"); }
    float& InterpPositionField() { return *GetNativePointerField<float*>(this, "AMatineeActor.InterpPosition"); }
    float& ClientSidePositionErrorToleranceField() { return *GetNativePointerField<float*>(this, "AMatineeActor.ClientSidePositionErrorTolerance"); }
    char& ReplicationForceIsPlayingField() { return *GetNativePointerField<char*>(this, "AMatineeActor.ReplicationForceIsPlaying"); }
 
    // Functions
 
    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "AMatineeActor.StaticClass"); }
    void AddActorToGroup(FName GroupName, AActor* TheGroupActor) { NativeCall<void, FName, AActor*>(this, "AMatineeActor.AddActorToGroup", GroupName, TheGroupActor); }
    FName* GetFunctionNameForEvent(FName* result, FName EventName) { return NativeCall<FName*, FName*, FName>(this, "AMatineeActor.GetFunctionNameForEvent", result, EventName); }
    void NotifyEventTriggered(FName EventName, float EventTime) { NativeCall<void, FName, float>(this, "AMatineeActor.NotifyEventTriggered", EventName, EventTime); }
    void Play(float OverrideSetPosition, bool bOverridePositionJump) { NativeCall<void, float, bool>(this, "AMatineeActor.Play", OverrideSetPosition, bOverridePositionJump); }
    void Reverse() { NativeCall<void>(this, "AMatineeActor.Reverse"); }
    void Stop() { NativeCall<void>(this, "AMatineeActor.Stop"); }
    void Pause() { NativeCall<void>(this, "AMatineeActor.Pause"); }
    void ChangePlaybackDirection() { NativeCall<void>(this, "AMatineeActor.ChangePlaybackDirection"); }
    void SetLoopingState(bool bNewLooping) { NativeCall<void, bool>(this, "AMatineeActor.SetLoopingState", bNewLooping); }
    void SetPosition(float NewPosition, bool bJump, bool bForceJumpFromBeginningForEvents, bool bSkipMatineeUpdate) { NativeCall<void, float, bool, bool, bool>(this, "AMatineeActor.SetPosition", NewPosition, bJump, bForceJumpFromBeginningForEvents, bSkipMatineeUpdate); }
    void AddPlayerToDirectorTracks(APlayerController* PC) { NativeCall<void, APlayerController*>(this, "AMatineeActor.AddPlayerToDirectorTracks", PC); }
    void Tick(float DeltaTime) { NativeCall<void, float>(this, "AMatineeActor.Tick", DeltaTime); }
    void UpdateStreamingForCameraCuts(float CurrentTime, bool bPreview) { NativeCall<void, float, bool>(this, "AMatineeActor.UpdateStreamingForCameraCuts", CurrentTime, bPreview); }
    void UpdateInterp(float NewPosition, bool bPreview, bool bJump, bool bSkipMatineeUpdate) { NativeCall<void, float, bool, bool, bool>(this, "AMatineeActor.UpdateInterp", NewPosition, bPreview, bJump, bSkipMatineeUpdate); }
    void InitInterp() { NativeCall<void>(this, "AMatineeActor.InitInterp"); }
    void TermInterp() { NativeCall<void>(this, "AMatineeActor.TermInterp"); }
    void SetupCameraCuts() { NativeCall<void>(this, "AMatineeActor.SetupCameraCuts"); }
    bool IsMatineeCompatibleWithPlayer(APlayerController* InPC) { return NativeCall<bool, APlayerController*>(this, "AMatineeActor.IsMatineeCompatibleWithPlayer", InPC); }
    void StepInterp(float DeltaTime, bool bPreview) { NativeCall<void, float, bool>(this, "AMatineeActor.StepInterp", DeltaTime, bPreview); }
    void EnableCinematicMode(bool bEnable) { NativeCall<void, bool>(this, "AMatineeActor.EnableCinematicMode", bEnable); }
    void PostLoadSubobjects(FObjectInstancingGraph* OuterInstanceGraph) { NativeCall<void, FObjectInstancingGraph*>(this, "AMatineeActor.PostLoadSubobjects", OuterInstanceGraph); }
    void UpdateReplicatedData(bool bIsBeginningPlay) { NativeCall<void, bool>(this, "AMatineeActor.UpdateReplicatedData", bIsBeginningPlay); }
    void BeginPlay() { NativeCall<void>(this, "AMatineeActor.BeginPlay"); }
    void ApplyWorldOffset(FVector* InOffset, bool bWorldShift) { NativeCall<void, FVector*, bool>(this, "AMatineeActor.ApplyWorldOffset", InOffset, bWorldShift); }
    void CheckPriorityRefresh() { NativeCall<void>(this, "AMatineeActor.CheckPriorityRefresh"); }
    void PostInitializeComponents() { NativeCall<void>(this, "AMatineeActor.PostInitializeComponents"); }
    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "AMatineeActor.GetLifetimeReplicatedProps", OutLifetimeProps); }
    void PreNetReceive() { NativeCall<void>(this, "AMatineeActor.PreNetReceive"); }
    void PostNetReceive() { NativeCall<void>(this, "AMatineeActor.PostNetReceive"); }
    void InitClientMatinee() { NativeCall<void>(this, "AMatineeActor.InitClientMatinee"); }
    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "AMatineeActor.GetPrivateStaticClass", Package); }
};
 
struct UMovementComponent : UActorComponent
{
    FVector& VelocityField() { return *GetNativePointerField<FVector*>(this, "UMovementComponent.Velocity"); }
};
 
struct UCharacterMovementComponent : UMovementComponent
{
    ACharacter * CharacterOwnerField() { return *GetNativePointerField<ACharacter**>(this, "UCharacterMovementComponent.CharacterOwner"); }
    float& MaxStepHeightField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.MaxStepHeight"); }
    float& JumpZVelocityField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.JumpZVelocity"); }
    float& JumpOffJumpZFactorField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.JumpOffJumpZFactor"); }
    bool& bSlipOffLedgesField() { return *GetNativePointerField<bool*>(this, "UCharacterMovementComponent.bSlipOffLedges"); }
    float& LedgeSlipCapsuleRadiusMultiplierField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.LedgeSlipCapsuleRadiusMultiplier"); }
    float& LedgeSlipPushVelocityField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.LedgeSlipPushVelocity"); }
    float& LedgeSlipVelocityBuildUpMultiplierField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.LedgeSlipVelocityBuildUpMultiplier"); }
    float& WalkableFloorAngleField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.WalkableFloorAngle"); }
    float& WalkableFloorZField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.WalkableFloorZ"); }
    long double& TimeLastAppliedImpulseField() { return *GetNativePointerField<long double*>(this, "UCharacterMovementComponent.TimeLastAppliedImpulse"); }
    TEnumAsByte<enum EMovementMode> & MovementModeField() { return *GetNativePointerField<TEnumAsByte<enum EMovementMode>*>(this, "UCharacterMovementComponent.MovementMode"); }
    char& CustomMovementModeField() { return *GetNativePointerField<char*>(this, "UCharacterMovementComponent.CustomMovementMode"); }
    FVector & OldBaseLocationField() { return *GetNativePointerField<FVector*>(this, "UCharacterMovementComponent.OldBaseLocation"); }
    FQuat & OldBaseQuatField() { return *GetNativePointerField<FQuat*>(this, "UCharacterMovementComponent.OldBaseQuat"); }
    long double& LastNonZeroAccelField() { return *GetNativePointerField<long double*>(this, "UCharacterMovementComponent.LastNonZeroAccel"); }
    float& CurrentLedgeSlipPushVelocityField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.CurrentLedgeSlipPushVelocity"); }
    int& LastFrameDisabledFloorBasingField() { return *GetNativePointerField<int*>(this, "UCharacterMovementComponent.LastFrameDisabledFloorBasing"); }
    long double& ForceBigPushingTimeField() { return *GetNativePointerField<long double*>(this, "UCharacterMovementComponent.ForceBigPushingTime"); }
    long double& LastClientMoveTimeField() { return *GetNativePointerField<long double*>(this, "UCharacterMovementComponent.LastClientMoveTime"); }
    float& GravityScaleField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.GravityScale"); }
    float& GroundFrictionField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.GroundFriction"); }
    float& MaxWalkSpeedField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.MaxWalkSpeed"); }
    float& MaxWalkSpeedCrouchedField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.MaxWalkSpeedCrouched"); }
    float& MaxWalkSpeedProneField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.MaxWalkSpeedProne"); }
    float& MaxCustomMovementSpeedField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.MaxCustomMovementSpeed"); }
    float& MaxSwimSpeedField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.MaxSwimSpeed"); }
    float& MaxFlySpeedField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.MaxFlySpeed"); }
    float& LandedPreventRequestedMoveIntervalField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.LandedPreventRequestedMoveInterval"); }
    float& LandedPreventRequestedMoveMinVelocityMagnitudeField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.LandedPreventRequestedMoveMinVelocityMagnitude"); }
    float& MinimumImpulseToApplyField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.MinimumImpulseToApply"); }
    long double& LastLandedTimeField() { return *GetNativePointerField<long double*>(this, "UCharacterMovementComponent.LastLandedTime"); }
    float& MaxAccelerationField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.MaxAcceleration"); }
    float& MaxImpulseVelocityMagnitudeField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.MaxImpulseVelocityMagnitude"); }
    float& MaxImpulseVelocityZField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.MaxImpulseVelocityZ"); }
    float& BrakingDecelerationWalkingField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.BrakingDecelerationWalking"); }
    float& BrakingDecelerationFallingField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.BrakingDecelerationFalling"); }
    float& BrakingDecelerationSwimmingField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.BrakingDecelerationSwimming"); }
    float& BrakingDecelerationFlyingField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.BrakingDecelerationFlying"); }
    float& AirControlField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.AirControl"); }
    float& AirControlBoostMultiplierField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.AirControlBoostMultiplier"); }
    float& AirControlBoostVelocityThresholdField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.AirControlBoostVelocityThreshold"); }
    float& FallingLateralFrictionField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.FallingLateralFriction"); }
    float& CrouchedHalfHeightField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.CrouchedHalfHeight"); }
    float& ProneHalfHeightField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.ProneHalfHeight"); }
    float& BuoyancyField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.Buoyancy"); }
    float& PerchRadiusThresholdField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.PerchRadiusThreshold"); }
    float& PerchAdditionalHeightField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.PerchAdditionalHeight"); }
    FRotator & RotationRateField() { return *GetNativePointerField<FRotator*>(this, "UCharacterMovementComponent.RotationRate"); }
    UPrimitiveComponent * DeferredUpdatedMoveComponentField() { return *GetNativePointerField<UPrimitiveComponent**>(this, "UCharacterMovementComponent.DeferredUpdatedMoveComponent"); }
    float& MaxOutOfWaterStepHeightField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.MaxOutOfWaterStepHeight"); }
    float& OutofWaterZField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.OutofWaterZ"); }
    float& MassField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.Mass"); }
    float& DinoClientPositionErrorToleranceStoppedField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.DinoClientPositionErrorToleranceStopped"); }
    float& DinoClientPositionErrorToleranceMovingFlyingField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.DinoClientPositionErrorToleranceMovingFlying"); }
    float& PlayerClientPositionErrorToleranceOverrideField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.PlayerClientPositionErrorToleranceOverride"); }
    float& SimulatedTickSkipDistanceSQField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.SimulatedTickSkipDistanceSQ"); }
    bool& bEnablePhysicsInteractionField() { return *GetNativePointerField<bool*>(this, "UCharacterMovementComponent.bEnablePhysicsInteraction"); }
    bool& bTouchForceScaledToMassField() { return *GetNativePointerField<bool*>(this, "UCharacterMovementComponent.bTouchForceScaledToMass"); }
    bool& bPushForceScaledToMassField() { return *GetNativePointerField<bool*>(this, "UCharacterMovementComponent.bPushForceScaledToMass"); }
    bool& bScalePushForceToVelocityField() { return *GetNativePointerField<bool*>(this, "UCharacterMovementComponent.bScalePushForceToVelocity"); }
    float& StandingDownwardForceScaleField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.StandingDownwardForceScale"); }
    float& InitialPushForceFactorField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.InitialPushForceFactor"); }
    float& PushForceFactorField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.PushForceFactor"); }
    float& PushForcePointZOffsetFactorField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.PushForcePointZOffsetFactor"); }
    float& TouchForceFactorField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.TouchForceFactor"); }
    float& MinTouchForceField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.MinTouchForce"); }
    float& MaxTouchForceField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.MaxTouchForce"); }
    float& RepulsionForceField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.RepulsionForce"); }
    FVector & LastUpdateLocationField() { return *GetNativePointerField<FVector*>(this, "UCharacterMovementComponent.LastUpdateLocation"); }
    FVector & MoveStartLocationField() { return *GetNativePointerField<FVector*>(this, "UCharacterMovementComponent.MoveStartLocation"); }
    float& AnalogInputModifierField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.AnalogInputModifier"); }
    float& BackwardsMaxSpeedMultiplierField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.BackwardsMaxSpeedMultiplier"); }
    float& BackwardsMovementDotThresholdField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.BackwardsMovementDotThreshold"); }
    FVector & PendingForceToApplyField() { return *GetNativePointerField<FVector*>(this, "UCharacterMovementComponent.PendingForceToApply"); }
    FVector & PendingImpulseToApplyField() { return *GetNativePointerField<FVector*>(this, "UCharacterMovementComponent.PendingImpulseToApply"); }
    FVector & AccelerationField() { return *GetNativePointerField<FVector*>(this, "UCharacterMovementComponent.Acceleration"); }
    float& MaxSimulationTimeStepField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.MaxSimulationTimeStep"); }
    int& MaxSimulationIterationsField() { return *GetNativePointerField<int*>(this, "UCharacterMovementComponent.MaxSimulationIterations"); }
    float& LedgeCheckThresholdField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.LedgeCheckThreshold"); }
    float& JumpOutOfWaterPitchField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.JumpOutOfWaterPitch"); }
    float& UpperImpactNormalScaleField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.UpperImpactNormalScale"); }
    TEnumAsByte<enum EMovementMode> & DefaultLandMovementModeField() { return *GetNativePointerField<TEnumAsByte<enum EMovementMode>*>(this, "UCharacterMovementComponent.DefaultLandMovementMode"); }
    TEnumAsByte<enum EMovementMode> & DefaultWaterMovementModeField() { return *GetNativePointerField<TEnumAsByte<enum EMovementMode>*>(this, "UCharacterMovementComponent.DefaultWaterMovementMode"); }
    float& PreventWaterHoppingPlaneOffsetField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.PreventWaterHoppingPlaneOffset"); }
    long double& PreventWaterHopping_LastTimeAtSurfaceField() { return *GetNativePointerField<long double*>(this, "UCharacterMovementComponent.PreventWaterHopping_LastTimeAtSurface"); }
    float& AccelerationFollowsRotationMinDotField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.AccelerationFollowsRotationMinDot"); }
    float& AccelerationFollowsRotationStopDistanceField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.AccelerationFollowsRotationStopDistance"); }
    float& RotationAccelerationField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.RotationAcceleration"); }
    float& RotationBrakingField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.RotationBraking"); }
    float& AngleToStartRotationBrakingField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.AngleToStartRotationBraking"); }
    float& SwimmingAccelZMultiplierField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.SwimmingAccelZMultiplier"); }
    float& TamedSwimmingAccelZMultiplierField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.TamedSwimmingAccelZMultiplier"); }
    bool& bHACKTickedField() { return *GetNativePointerField<bool*>(this, "UCharacterMovementComponent.bHACKTicked"); }
    bool& bHackTestDisableRotationCodeField() { return *GetNativePointerField<bool*>(this, "UCharacterMovementComponent.bHackTestDisableRotationCode"); }
    FVector & LastForcedNetVelocityField() { return *GetNativePointerField<FVector*>(this, "UCharacterMovementComponent.LastForcedNetVelocity"); }
    long double& LastStepUpTimeField() { return *GetNativePointerField<long double*>(this, "UCharacterMovementComponent.LastStepUpTime"); }
    int& BadFloorPenetrationCountField() { return *GetNativePointerField<int*>(this, "UCharacterMovementComponent.BadFloorPenetrationCount"); }
    FVector & AvoidanceLockVelocityField() { return *GetNativePointerField<FVector*>(this, "UCharacterMovementComponent.AvoidanceLockVelocity"); }
    float& AvoidanceLockTimerField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.AvoidanceLockTimer"); }
    long double& LastSkippedMoveTimeField() { return *GetNativePointerField<long double*>(this, "UCharacterMovementComponent.LastSkippedMoveTime"); }
    long double& LastSwimTimeField() { return *GetNativePointerField<long double*>(this, "UCharacterMovementComponent.LastSwimTime"); }
    FRotator & CurrentRotationSpeedField() { return *GetNativePointerField<FRotator*>(this, "UCharacterMovementComponent.CurrentRotationSpeed"); }
    FVector & RequestedVelocityField() { return *GetNativePointerField<FVector*>(this, "UCharacterMovementComponent.RequestedVelocity"); }
    long double& DisableMovementPhysicsUntilTimeField() { return *GetNativePointerField<long double*>(this, "UCharacterMovementComponent.DisableMovementPhysicsUntilTime"); }
    float& LostDeltaTimeField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.LostDeltaTime"); }
    float& LastLostDeltaTimeField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.LastLostDeltaTime"); }
    int& AvoidanceUIDField() { return *GetNativePointerField<int*>(this, "UCharacterMovementComponent.AvoidanceUID"); }
    float& AvoidanceWeightField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.AvoidanceWeight"); }
    FVector & PendingLaunchVelocityField() { return *GetNativePointerField<FVector*>(this, "UCharacterMovementComponent.PendingLaunchVelocity"); }
    FNetworkPredictionData_Client_Character * ClientPredictionDataField() { return *GetNativePointerField<FNetworkPredictionData_Client_Character**>(this, "UCharacterMovementComponent.ClientPredictionData"); }
    FNetworkPredictionData_Server_Character * ServerPredictionDataField() { return *GetNativePointerField<FNetworkPredictionData_Server_Character**>(this, "UCharacterMovementComponent.ServerPredictionData"); }
    TArray<FTraceHandle> & PendingAsyncTracesField() { return *GetNativePointerField<TArray<FTraceHandle>*>(this, "UCharacterMovementComponent.PendingAsyncTraces"); }
    float& MinTimeBetweenTimeStampResetsField() { return *GetNativePointerField<float*>(this, "UCharacterMovementComponent.MinTimeBetweenTimeStampResets"); }
    TArray<FStoredMoveData> & ClientMovedDataField() { return *GetNativePointerField<TArray<FStoredMoveData>*>(this, "UCharacterMovementComponent.ClientMovedData"); }
    bool& bWasSimulatingRootMotionField() { return *GetNativePointerField<bool*>(this, "UCharacterMovementComponent.bWasSimulatingRootMotion"); }
    FVector & LastCheckedFloorAtRelativeLocField() { return *GetNativePointerField<FVector*>(this, "UCharacterMovementComponent.LastCheckedFloorAtRelativeLoc"); }
 
    // Bit fields
 
    BitFieldValue<bool, unsigned __int32> bReplicateRelativeToAttachedParent() { return { this, "UCharacterMovementComponent.bReplicateRelativeToAttachedParent" }; }
    BitFieldValue<bool, unsigned __int32> bFindFloorOnce() { return { this, "UCharacterMovementComponent.bFindFloorOnce" }; }
    BitFieldValue<bool, unsigned __int32> bPreventExitingWaterForceExtraOverlap() { return { this, "UCharacterMovementComponent.bPreventExitingWaterForceExtraOverlap" }; }
    BitFieldValue<bool, unsigned __int32> bUseControllerDesiredRotation() { return { this, "UCharacterMovementComponent.bUseControllerDesiredRotation" }; }
    BitFieldValue<bool, unsigned __int32> bRequireAccelerationForUseControllerDesiredRotation() { return { this, "UCharacterMovementComponent.bRequireAccelerationForUseControllerDesiredRotation" }; }
    BitFieldValue<bool, unsigned __int32> bForceDontAllowDesiredRotationWhenFalling() { return { this, "UCharacterMovementComponent.bForceDontAllowDesiredRotationWhenFalling" }; }
    BitFieldValue<bool, unsigned __int32> bUseCharacterInterpolationAndStops() { return { this, "UCharacterMovementComponent.bUseCharacterInterpolationAndStops" }; }
    BitFieldValue<bool, unsigned __int32> bOnlyForwardsInputAcceleration() { return { this, "UCharacterMovementComponent.bOnlyForwardsInputAcceleration" }; }
    BitFieldValue<bool, unsigned __int32> bOnlyForwardsInputAccelerationWalking() { return { this, "UCharacterMovementComponent.bOnlyForwardsInputAccelerationWalking" }; }
    BitFieldValue<bool, unsigned __int32> bReduceBackwardsMovement() { return { this, "UCharacterMovementComponent.bReduceBackwardsMovement" }; }
    BitFieldValue<bool, unsigned __int32> bUseAsyncWalking() { return { this, "UCharacterMovementComponent.bUseAsyncWalking" }; }
    BitFieldValue<bool, unsigned __int32> bAllowSimulatedTickDistanceSkip() { return { this, "UCharacterMovementComponent.bAllowSimulatedTickDistanceSkip" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPAcknowledgeServerCorrection() { return { this, "UCharacterMovementComponent.bUseBPAcknowledgeServerCorrection" }; }
    BitFieldValue<bool, unsigned __int32> bAllowImpactDeflection() { return { this, "UCharacterMovementComponent.bAllowImpactDeflection" }; }
    BitFieldValue<bool, unsigned __int32> bDisableSimulatedMovement() { return { this, "UCharacterMovementComponent.bDisableSimulatedMovement" }; }
    BitFieldValue<bool, unsigned __int32> bLastAllowSimulate() { return { this, "UCharacterMovementComponent.bLastAllowSimulate" }; }
    BitFieldValue<bool, unsigned __int32> bZeroPitchWhenNoAcceleration() { return { this, "UCharacterMovementComponent.bZeroPitchWhenNoAcceleration" }; }
    BitFieldValue<bool, unsigned __int32> bPreventSlidingWhileFalling() { return { this, "UCharacterMovementComponent.bPreventSlidingWhileFalling" }; }
    BitFieldValue<bool, unsigned __int32> bPreventAddingImpulse() { return { this, "UCharacterMovementComponent.bPreventAddingImpulse" }; }
    BitFieldValue<bool, unsigned __int32> bPreventZeroPitchAndRollWhileFalling() { return { this, "UCharacterMovementComponent.bPreventZeroPitchAndRollWhileFalling" }; }
    BitFieldValue<bool, unsigned __int32> bOrientRotationToMovement() { return { this, "UCharacterMovementComponent.bOrientRotationToMovement" }; }
    BitFieldValue<bool, unsigned __int32> bAssumeSymmetricalRotation() { return { this, "UCharacterMovementComponent.bAssumeSymmetricalRotation" }; }
    BitFieldValue<bool, unsigned __int32> bMovementInProgress() { return { this, "UCharacterMovementComponent.bMovementInProgress" }; }
    BitFieldValue<bool, unsigned __int32> bEnableScopedMovementUpdates() { return { this, "UCharacterMovementComponent.bEnableScopedMovementUpdates" }; }
    BitFieldValue<bool, unsigned __int32> bForceMaxAccel() { return { this, "UCharacterMovementComponent.bForceMaxAccel" }; }
    BitFieldValue<bool, unsigned __int32> bRunPhysicsWithNoController() { return { this, "UCharacterMovementComponent.bRunPhysicsWithNoController" }; }
    BitFieldValue<bool, unsigned __int32> bForceNextFloorCheck() { return { this, "UCharacterMovementComponent.bForceNextFloorCheck" }; }
    BitFieldValue<bool, unsigned __int32> bShrinkProxyCapsule() { return { this, "UCharacterMovementComponent.bShrinkProxyCapsule" }; }
    BitFieldValue<bool, unsigned __int32> bCanWalkOffLedges() { return { this, "UCharacterMovementComponent.bCanWalkOffLedges" }; }
    BitFieldValue<bool, unsigned __int32> bCanWalkOffLedgesWhenCrouching() { return { this, "UCharacterMovementComponent.bCanWalkOffLedgesWhenCrouching" }; }
    BitFieldValue<bool, unsigned __int32> bDeferUpdateMoveComponent() { return { this, "UCharacterMovementComponent.bDeferUpdateMoveComponent" }; }
    BitFieldValue<bool, unsigned __int32> bUseRootMotionForLocomotion() { return { this, "UCharacterMovementComponent.bUseRootMotionForLocomotion" }; }
    BitFieldValue<bool, unsigned __int32> bForceBraking_DEPRECATED() { return { this, "UCharacterMovementComponent.bForceBraking_DEPRECATED" }; }
    BitFieldValue<bool, unsigned __int32> bMaintainHorizontalGroundVelocity() { return { this, "UCharacterMovementComponent.bMaintainHorizontalGroundVelocity" }; }
    BitFieldValue<bool, unsigned __int32> bImpartBaseVelocityX() { return { this, "UCharacterMovementComponent.bImpartBaseVelocityX" }; }
    BitFieldValue<bool, unsigned __int32> bImpartBaseVelocityY() { return { this, "UCharacterMovementComponent.bImpartBaseVelocityY" }; }
    BitFieldValue<bool, unsigned __int32> bImpartBaseVelocityZ() { return { this, "UCharacterMovementComponent.bImpartBaseVelocityZ" }; }
    BitFieldValue<bool, unsigned __int32> bImpartBaseAngularVelocity() { return { this, "UCharacterMovementComponent.bImpartBaseAngularVelocity" }; }
    BitFieldValue<bool, unsigned __int32> bCanSlide() { return { this, "UCharacterMovementComponent.bCanSlide" }; }
    BitFieldValue<bool, unsigned __int32> bJustTeleported() { return { this, "UCharacterMovementComponent.bJustTeleported" }; }
    BitFieldValue<bool, unsigned __int32> bNetworkUpdateReceived() { return { this, "UCharacterMovementComponent.bNetworkUpdateReceived" }; }
    BitFieldValue<bool, unsigned __int32> bNetworkMovementModeChanged() { return { this, "UCharacterMovementComponent.bNetworkMovementModeChanged" }; }
    BitFieldValue<bool, unsigned __int32> bNotifyApex() { return { this, "UCharacterMovementComponent.bNotifyApex" }; }
    BitFieldValue<bool, unsigned __int32> bCheatFlying() { return { this, "UCharacterMovementComponent.bCheatFlying" }; }
    BitFieldValue<bool, unsigned __int32> bWantsToCrouch() { return { this, "UCharacterMovementComponent.bWantsToCrouch" }; }
    BitFieldValue<bool, unsigned __int32> bWantsToProne() { return { this, "UCharacterMovementComponent.bWantsToProne" }; }
    BitFieldValue<bool, unsigned __int32> bCrouchMaintainsBaseLocation() { return { this, "UCharacterMovementComponent.bCrouchMaintainsBaseLocation" }; }
    BitFieldValue<bool, unsigned __int32> bIgnoreBaseRotation() { return { this, "UCharacterMovementComponent.bIgnoreBaseRotation" }; }
    BitFieldValue<bool, unsigned __int32> bFastAttachedMove() { return { this, "UCharacterMovementComponent.bFastAttachedMove" }; }
    BitFieldValue<bool, unsigned __int32> bAlwaysCheckFloor() { return { this, "UCharacterMovementComponent.bAlwaysCheckFloor" }; }
    BitFieldValue<bool, unsigned __int32> bUseFlatBaseForFloorChecks() { return { this, "UCharacterMovementComponent.bUseFlatBaseForFloorChecks" }; }
    BitFieldValue<bool, unsigned __int32> bPerformingJumpOff() { return { this, "UCharacterMovementComponent.bPerformingJumpOff" }; }
    BitFieldValue<bool, unsigned __int32> bRequestedMoveUseAcceleration() { return { this, "UCharacterMovementComponent.bRequestedMoveUseAcceleration" }; }
    BitFieldValue<bool, unsigned __int32> bAccelerationFollowsRotation() { return { this, "UCharacterMovementComponent.bAccelerationFollowsRotation" }; }
    BitFieldValue<bool, unsigned __int32> bPreventWaterSurfaceHopping() { return { this, "UCharacterMovementComponent.bPreventWaterSurfaceHopping" }; }
    BitFieldValue<bool, unsigned __int32> bCheckFallingAITempIgnoreDinoRiderMesh() { return { this, "UCharacterMovementComponent.bCheckFallingAITempIgnoreDinoRiderMesh" }; }
    BitFieldValue<bool, unsigned __int32> bAlwaysCheckForInvallidFloor() { return { this, "UCharacterMovementComponent.bAlwaysCheckForInvallidFloor" }; }
    BitFieldValue<bool, unsigned __int32> bFallingAITempIgnoreDinoRiderMesh() { return { this, "UCharacterMovementComponent.bFallingAITempIgnoreDinoRiderMesh" }; }
    BitFieldValue<bool, unsigned __int32> bUseRotationAcceleration() { return { this, "UCharacterMovementComponent.bUseRotationAcceleration" }; }
    BitFieldValue<bool, unsigned __int32> bIgnoreRotationAccelerationWhenSwimming() { return { this, "UCharacterMovementComponent.bIgnoreRotationAccelerationWhenSwimming" }; }
    BitFieldValue<bool, unsigned __int32> bPreventPhysicsModeChange() { return { this, "UCharacterMovementComponent.bPreventPhysicsModeChange" }; }
    BitFieldValue<bool, unsigned __int32> bLastHasRequestedVelocity() { return { this, "UCharacterMovementComponent.bLastHasRequestedVelocity" }; }
    BitFieldValue<bool, unsigned __int32> bHasRequestedVelocity() { return { this, "UCharacterMovementComponent.bHasRequestedVelocity" }; }
    BitFieldValue<bool, unsigned __int32> bRequestedMoveWithMaxSpeed() { return { this, "UCharacterMovementComponent.bRequestedMoveWithMaxSpeed" }; }
    BitFieldValue<bool, unsigned __int32> bWasAvoidanceUpdated() { return { this, "UCharacterMovementComponent.bWasAvoidanceUpdated" }; }
    BitFieldValue<bool, unsigned __int32> bUseRVOPostProcess() { return { this, "UCharacterMovementComponent.bUseRVOPostProcess" }; }
    BitFieldValue<bool, unsigned __int32> bDeferUpdateBasedMovement() { return { this, "UCharacterMovementComponent.bDeferUpdateBasedMovement" }; }
    BitFieldValue<bool, unsigned __int32> bPreventExitingWater() { return { this, "UCharacterMovementComponent.bPreventExitingWater" }; }
    BitFieldValue<bool, unsigned __int32> bForcePreventExitingWater() { return { this, "UCharacterMovementComponent.bForcePreventExitingWater" }; }
    BitFieldValue<bool, unsigned __int32> bPreventEnteringWater() { return { this, "UCharacterMovementComponent.bPreventEnteringWater" }; }
    BitFieldValue<bool, unsigned __int32> bPendingLaunchNoLowerVelocity() { return { this, "UCharacterMovementComponent.bPendingLaunchNoLowerVelocity" }; }
    BitFieldValue<bool, unsigned __int32> bForceNextTickUpdate() { return { this, "UCharacterMovementComponent.bForceNextTickUpdate" }; }
 
    // Functions
 
    bool HasPredictionData_Server() { return NativeCall<bool>(this, "UCharacterMovementComponent.HasPredictionData_Server"); }
    bool HasPredictionData_Client() { return NativeCall<bool>(this, "UCharacterMovementComponent.HasPredictionData_Client"); }
    UObject * GetUObjectInterfaceNetworkPredictionInterface() { return NativeCall<UObject*>(this, "UCharacterMovementComponent.GetUObjectInterfaceNetworkPredictionInterface"); }
    float GetJumpZVelocity() { return NativeCall<float>(this, "UCharacterMovementComponent.GetJumpZVelocity"); }
    void OnUnregister() { NativeCall<void>(this, "UCharacterMovementComponent.OnUnregister"); }
    void PostLoad() { NativeCall<void>(this, "UCharacterMovementComponent.PostLoad"); }
    void OnRegister() { NativeCall<void>(this, "UCharacterMovementComponent.OnRegister"); }
    void BeginDestroy() { NativeCall<void>(this, "UCharacterMovementComponent.BeginDestroy"); }
    void SetUpdatedComponent(UPrimitiveComponent * NewUpdatedComponent) { NativeCall<void, UPrimitiveComponent*>(this, "UCharacterMovementComponent.SetUpdatedComponent", NewUpdatedComponent); }
    bool HasValidData() { return NativeCall<bool>(this, "UCharacterMovementComponent.HasValidData"); }
    bool DoJump(bool bReplayingMoves) { return NativeCall<bool, bool>(this, "UCharacterMovementComponent.DoJump", bReplayingMoves); }
    FVector * GetImpartedMovementBaseVelocity(FVector * result) { return NativeCall<FVector*, FVector*>(this, "UCharacterMovementComponent.GetImpartedMovementBaseVelocity", result); }
    void Launch(FVector * LaunchVel, bool bNoLowerVelocity) { NativeCall<void, FVector*, bool>(this, "UCharacterMovementComponent.Launch", LaunchVel, bNoLowerVelocity); }
    bool HandlePendingLaunch() { return NativeCall<bool>(this, "UCharacterMovementComponent.HandlePendingLaunch"); }
    void JumpOff(AActor * MovementBaseActor) { NativeCall<void, AActor*>(this, "UCharacterMovementComponent.JumpOff", MovementBaseActor); }
    FVector * GetBestDirectionOffActor(FVector * result, AActor * BaseActor) { return NativeCall<FVector*, FVector*, AActor*>(this, "UCharacterMovementComponent.GetBestDirectionOffActor", result, BaseActor); }
    float GetNetworkSafeRandomAngleDegrees() { return NativeCall<float>(this, "UCharacterMovementComponent.GetNetworkSafeRandomAngleDegrees"); }
    void SetDefaultMovementMode() { NativeCall<void>(this, "UCharacterMovementComponent.SetDefaultMovementMode"); }
    void SetMovementMode(EMovementMode NewMovementMode, char NewCustomMode) { NativeCall<void, EMovementMode, char>(this, "UCharacterMovementComponent.SetMovementMode", NewMovementMode, NewCustomMode); }
    void OnMovementModeChanged(EMovementMode PreviousMovementMode, char PreviousCustomMode) { NativeCall<void, EMovementMode, char>(this, "UCharacterMovementComponent.OnMovementModeChanged", PreviousMovementMode, PreviousCustomMode); }
    bool MoveUpdatedComponentImpl(FVector * Delta, FQuat * NewRotation, bool bSweep, FHitResult * OutHit) { return NativeCall<bool, FVector*, FQuat*, bool, FHitResult*>(this, "UCharacterMovementComponent.MoveUpdatedComponentImpl", Delta, NewRotation, bSweep, OutHit); }
    char PackNetworkMovementMode() { return NativeCall<char>(this, "UCharacterMovementComponent.PackNetworkMovementMode"); }
    void ApplyNetworkMovementMode(const char ReceivedMode) { NativeCall<void, const char>(this, "UCharacterMovementComponent.ApplyNetworkMovementMode", ReceivedMode); }
    void PerformAirControl(FVector Direction, float ZDiff) { NativeCall<void, FVector, float>(this, "UCharacterMovementComponent.PerformAirControl", Direction, ZDiff); }
    void PerformAirControlForPathFollowing(FVector Direction, float ZDiff) { NativeCall<void, FVector, float>(this, "UCharacterMovementComponent.PerformAirControlForPathFollowing", Direction, ZDiff); }
    void ExecuteStoredMoves() { NativeCall<void>(this, "UCharacterMovementComponent.ExecuteStoredMoves"); }
    void AdjustProxyCapsuleSize() { NativeCall<void>(this, "UCharacterMovementComponent.AdjustProxyCapsuleSize"); }
    void SimulatedTick(float DeltaSeconds) { NativeCall<void, float>(this, "UCharacterMovementComponent.SimulatedTick", DeltaSeconds); }
    void SimulateMovement(float DeltaSeconds) { NativeCall<void, float>(this, "UCharacterMovementComponent.SimulateMovement", DeltaSeconds); }
    UPrimitiveComponent * GetMovementBase() { return NativeCall<UPrimitiveComponent*>(this, "UCharacterMovementComponent.GetMovementBase"); }
    void SetBase(UPrimitiveComponent * NewBase, FName BoneName, bool bNotifyActor) { NativeCall<void, UPrimitiveComponent*, FName, bool>(this, "UCharacterMovementComponent.SetBase", NewBase, BoneName, bNotifyActor); }
    void MaybeUpdateBasedMovement(float DeltaSeconds) { NativeCall<void, float>(this, "UCharacterMovementComponent.MaybeUpdateBasedMovement", DeltaSeconds); }
    void MaybeSaveBaseLocation() { NativeCall<void>(this, "UCharacterMovementComponent.MaybeSaveBaseLocation"); }
    void UpdateBasedMovement(float DeltaSeconds) { NativeCall<void, float>(this, "UCharacterMovementComponent.UpdateBasedMovement", DeltaSeconds); }
    void UpdateBasedRotation(FRotator * FinalRotation, FRotator * ReducedRotation) { NativeCall<void, FRotator*, FRotator*>(this, "UCharacterMovementComponent.UpdateBasedRotation", FinalRotation, ReducedRotation); }
    void DisableMovement() { NativeCall<void>(this, "UCharacterMovementComponent.DisableMovement"); }
    void PerformMovement(float DeltaSeconds) { NativeCall<void, float>(this, "UCharacterMovementComponent.PerformMovement", DeltaSeconds); }
    void CallMovementUpdateDelegate(float DeltaTime, FVector * OldLocation, FVector * OldVelocity) { NativeCall<void, float, FVector*, FVector*>(this, "UCharacterMovementComponent.CallMovementUpdateDelegate", DeltaTime, OldLocation, OldVelocity); }
    void SaveBaseLocation() { NativeCall<void>(this, "UCharacterMovementComponent.SaveBaseLocation"); }
    bool CanCrouchInCurrentState() { return NativeCall<bool>(this, "UCharacterMovementComponent.CanCrouchInCurrentState"); }
    bool IsWalking() { return NativeCall<bool>(this, "UCharacterMovementComponent.IsWalking"); }
    void Crouch(bool bClientSimulation) { NativeCall<void, bool>(this, "UCharacterMovementComponent.Crouch", bClientSimulation); }
    void UnCrouch(bool bClientSimulation, bool bForce) { NativeCall<void, bool, bool>(this, "UCharacterMovementComponent.UnCrouch", bClientSimulation, bForce); }
    void StartNewPhysics(float deltaTime, int Iterations) { NativeCall<void, float, int>(this, "UCharacterMovementComponent.StartNewPhysics", deltaTime, Iterations); }
    float GetGravityZ() { return NativeCall<float>(this, "UCharacterMovementComponent.GetGravityZ"); }
    float GetMaxSpeed() { return NativeCall<float>(this, "UCharacterMovementComponent.GetMaxSpeed"); }
    bool ResolvePenetrationImpl(FVector * Adjustment, FHitResult * Hit, FQuat * NewRotation) { return NativeCall<bool, FVector*, FHitResult*, FQuat*>(this, "UCharacterMovementComponent.ResolvePenetrationImpl", Adjustment, Hit, NewRotation); }
    float SlideAlongSurface(FVector * Delta, float Time, FVector * InNormal, FHitResult * Hit, bool bHandleImpact) { return NativeCall<float, FVector*, float, FVector*, FHitResult*, bool>(this, "UCharacterMovementComponent.SlideAlongSurface", Delta, Time, InNormal, Hit, bHandleImpact); }
    void TwoWallAdjust(FVector * Delta, FHitResult * Hit, FVector * OldHitNormal) { NativeCall<void, FVector*, FHitResult*, FVector*>(this, "UCharacterMovementComponent.TwoWallAdjust", Delta, Hit, OldHitNormal); }
    FVector * ComputeSlideVector(FVector * result, FVector * InDelta, const float Time, FVector * Normal, FHitResult * Hit) { return NativeCall<FVector*, FVector*, FVector*, const float, FVector*, FHitResult*>(this, "UCharacterMovementComponent.ComputeSlideVector", result, InDelta, Time, Normal, Hit); }
    FVector * HandleSlopeBoosting(FVector * result, FVector * SlideResult, FVector * Delta, const float Time, FVector * Normal, FHitResult * Hit) { return NativeCall<FVector*, FVector*, FVector*, FVector*, const float, FVector*, FHitResult*>(this, "UCharacterMovementComponent.HandleSlopeBoosting", result, SlideResult, Delta, Time, Normal, Hit); }
    FVector * AdjustUpperHemisphereImpact(FVector * result, FVector * Delta, FHitResult * Hit) { return NativeCall<FVector*, FVector*, FVector*, FHitResult*>(this, "UCharacterMovementComponent.AdjustUpperHemisphereImpact", result, Delta, Hit); }
    FVector * NewFallVelocity(FVector * result, FVector * InitialVelocity, FVector * Gravity, float DeltaTime) { return NativeCall<FVector*, FVector*, FVector*, FVector*, float>(this, "UCharacterMovementComponent.NewFallVelocity", result, InitialVelocity, Gravity, DeltaTime); }
    float ImmersionDepth(bool bUseLineTrace) { return NativeCall<float, bool>(this, "UCharacterMovementComponent.ImmersionDepth", bUseLineTrace); }
    bool IsFlying() { return NativeCall<bool>(this, "UCharacterMovementComponent.IsFlying"); }
    bool IsMovingOnGround() { return NativeCall<bool>(this, "UCharacterMovementComponent.IsMovingOnGround"); }
    bool IsFalling() { return NativeCall<bool>(this, "UCharacterMovementComponent.IsFalling"); }
    bool IsSwimming() { return NativeCall<bool>(this, "UCharacterMovementComponent.IsSwimming"); }
    bool IsCrouching() { return NativeCall<bool>(this, "UCharacterMovementComponent.IsCrouching"); }
    bool IsProne() { return NativeCall<bool>(this, "UCharacterMovementComponent.IsProne"); }
    void CalcVelocity(float DeltaTime, float Friction, bool bFluid, float BrakingDeceleration) { NativeCall<void, float, float, bool, float>(this, "UCharacterMovementComponent.CalcVelocity", DeltaTime, Friction, bFluid, BrakingDeceleration); }
    bool ApplyRequestedMove(float DeltaTime, float MaxAccel, float MaxSpeed, float Friction, float BrakingDeceleration, FVector * OutAcceleration, float* OutRequestedSpeed) { return NativeCall<bool, float, float, float, float, float, FVector*, float*>(this, "UCharacterMovementComponent.ApplyRequestedMove", DeltaTime, MaxAccel, MaxSpeed, Friction, BrakingDeceleration, OutAcceleration, OutRequestedSpeed); }
    void RequestDirectMove(FVector * MoveVelocity, bool bForceMaxSpeed) { NativeCall<void, FVector*, bool>(this, "UCharacterMovementComponent.RequestDirectMove", MoveVelocity, bForceMaxSpeed); }
    bool CanStopPathFollowing() { return NativeCall<bool>(this, "UCharacterMovementComponent.CanStopPathFollowing"); }
    void NotifyBumpedPawn(APawn * BumpedPawn) { NativeCall<void, APawn*>(this, "UCharacterMovementComponent.NotifyBumpedPawn", BumpedPawn); }
    float GetMaxJumpHeight() { return NativeCall<float>(this, "UCharacterMovementComponent.GetMaxJumpHeight"); }
    float GetModifiedMaxAcceleration() { return NativeCall<float>(this, "UCharacterMovementComponent.GetModifiedMaxAcceleration"); }
    float K2_GetModifiedMaxAcceleration() { return NativeCall<float>(this, "UCharacterMovementComponent.K2_GetModifiedMaxAcceleration"); }
    float GetMaxAcceleration() { return NativeCall<float>(this, "UCharacterMovementComponent.GetMaxAcceleration"); }
    void ApplyVelocityBraking(float DeltaTime, float Friction, float BrakingDeceleration) { NativeCall<void, float, float, float>(this, "UCharacterMovementComponent.ApplyVelocityBraking", DeltaTime, Friction, BrakingDeceleration); }
    bool PhysFlyingAsync(float deltaTime, int Iterations, float friction, float brakingDeceleration) { return NativeCall<bool, float, int, float, float>(this, "UCharacterMovementComponent.PhysFlyingAsync", deltaTime, Iterations, friction, brakingDeceleration); }
    void PhysFlying(float deltaTime, int Iterations, float friction, float brakingDeceleration) { NativeCall<void, float, int, float, float>(this, "UCharacterMovementComponent.PhysFlying", deltaTime, Iterations, friction, brakingDeceleration); }
    void PhysSwimming(float deltaTime, int Iterations) { NativeCall<void, float, int>(this, "UCharacterMovementComponent.PhysSwimming", deltaTime, Iterations); }
    void StartSwimming(FVector OldLocation, FVector OldVelocity, float timeTick, float remainingTime, int Iterations) { NativeCall<void, FVector, FVector, float, float, int>(this, "UCharacterMovementComponent.StartSwimming", OldLocation, OldVelocity, timeTick, remainingTime, Iterations); }
    float Swim(FVector Delta, FHitResult * Hit) { return NativeCall<float, FVector, FHitResult*>(this, "UCharacterMovementComponent.Swim", Delta, Hit); }
    FVector * FindWaterLine(FVector * result, FVector InWater, FVector OutofWater) { return NativeCall<FVector*, FVector*, FVector, FVector>(this, "UCharacterMovementComponent.FindWaterLine", result, InWater, OutofWater); }
    void NotifyJumpApex() { NativeCall<void>(this, "UCharacterMovementComponent.NotifyJumpApex"); }
    FVector * GetFallingLateralAcceleration(FVector * result, float DeltaTime) { return NativeCall<FVector*, FVector*, float>(this, "UCharacterMovementComponent.GetFallingLateralAcceleration", result, DeltaTime); }
    float GetAirControl(float DeltaTime, float TickAirControl, FVector * FallAcceleration) { return NativeCall<float, float, float, FVector*>(this, "UCharacterMovementComponent.GetAirControl", DeltaTime, TickAirControl, FallAcceleration); }
    float BoostAirControl(float DeltaTime, float TickAirControl, FVector * FallAcceleration) { return NativeCall<float, float, float, FVector*>(this, "UCharacterMovementComponent.BoostAirControl", DeltaTime, TickAirControl, FallAcceleration); }
    void PhysFalling(float deltaTime, int Iterations) { NativeCall<void, float, int>(this, "UCharacterMovementComponent.PhysFalling", deltaTime, Iterations); }
    bool FindAirControlImpact(float DeltaTime, float TickAirControl, FVector * FallAcceleration, FHitResult * OutHitResult) { return NativeCall<bool, float, float, FVector*, FHitResult*>(this, "UCharacterMovementComponent.FindAirControlImpact", DeltaTime, TickAirControl, FallAcceleration, OutHitResult); }
    float LimitAirControl(float DeltaTime, float TickAirControl, FVector * FallAcceleration, FHitResult * HitResult) { return NativeCall<float, float, float, FVector*, FHitResult*>(this, "UCharacterMovementComponent.LimitAirControl", DeltaTime, TickAirControl, FallAcceleration, HitResult); }
    bool CheckLedgeDirection(FVector * OldLocation, FVector * SideStep, FVector * GravDir) { return NativeCall<bool, FVector*, FVector*, FVector*>(this, "UCharacterMovementComponent.CheckLedgeDirection", OldLocation, SideStep, GravDir); }
    FVector * GetLedgeMove(FVector * result, FVector * OldLocation, FVector * Delta, FVector * GravDir) { return NativeCall<FVector*, FVector*, FVector*, FVector*, FVector*>(this, "UCharacterMovementComponent.GetLedgeMove", result, OldLocation, Delta, GravDir); }
    bool CanWalkOffLedges() { return NativeCall<bool>(this, "UCharacterMovementComponent.CanWalkOffLedges"); }
    bool CheckFall(FHitResult * Hit, FVector Delta, FVector subLoc, float remainingTime, float timeTick, int Iterations, bool bMustJump) { return NativeCall<bool, FHitResult*, FVector, FVector, float, float, int, bool>(this, "UCharacterMovementComponent.CheckFall", Hit, Delta, subLoc, remainingTime, timeTick, Iterations, bMustJump); }
    void StartFalling(int Iterations, float remainingTime, float timeTick, FVector * Delta, FVector * subLoc) { NativeCall<void, int, float, float, FVector*, FVector*>(this, "UCharacterMovementComponent.StartFalling", Iterations, remainingTime, timeTick, Delta, subLoc); }
    FVector * ComputeGroundMovementDelta(FVector * result, FVector * Delta, FHitResult * RampHit, const bool bHitFromLineTrace) { return NativeCall<FVector*, FVector*, FVector*, FHitResult*, const bool>(this, "UCharacterMovementComponent.ComputeGroundMovementDelta", result, Delta, RampHit, bHitFromLineTrace); }
    void MaintainHorizontalGroundVelocity() { NativeCall<void>(this, "UCharacterMovementComponent.MaintainHorizontalGroundVelocity"); }
    bool PhysWalkingAsync(float deltaTime, int Iterations) { return NativeCall<bool, float, int>(this, "UCharacterMovementComponent.PhysWalkingAsync", deltaTime, Iterations); }
    void PhysWalking(float deltaTime, int Iterations) { NativeCall<void, float, int>(this, "UCharacterMovementComponent.PhysWalking", deltaTime, Iterations); }
    void PhysCustom(float deltaTime, int Iterations) { NativeCall<void, float, int>(this, "UCharacterMovementComponent.PhysCustom", deltaTime, Iterations); }
    void AdjustFloorHeight() { NativeCall<void>(this, "UCharacterMovementComponent.AdjustFloorHeight"); }
    void StopActiveMovement() { NativeCall<void>(this, "UCharacterMovementComponent.StopActiveMovement"); }
    void ProcessLanded(FHitResult * Hit, float remainingTime, int Iterations) { NativeCall<void, FHitResult*, float, int>(this, "UCharacterMovementComponent.ProcessLanded", Hit, remainingTime, Iterations); }
    void SetPostLandedPhysics(FHitResult * Hit) { NativeCall<void, FHitResult*>(this, "UCharacterMovementComponent.SetPostLandedPhysics", Hit); }
    void OnTeleported() { NativeCall<void>(this, "UCharacterMovementComponent.OnTeleported"); }
    FRotator * GetDeltaRotation(FRotator * result, float DeltaTime) { return NativeCall<FRotator*, FRotator*, float>(this, "UCharacterMovementComponent.GetDeltaRotation", result, DeltaTime); }
    FRotator * ComputeOrientToMovementRotation(FRotator * result, FRotator * CurrentRotation, float DeltaTime, FRotator * DeltaRotation) { return NativeCall<FRotator*, FRotator*, FRotator*, float, FRotator*>(this, "UCharacterMovementComponent.ComputeOrientToMovementRotation", result, CurrentRotation, DeltaTime, DeltaRotation); }
    void PhysicsRotation(float DeltaTime) { NativeCall<void, float>(this, "UCharacterMovementComponent.PhysicsRotation", DeltaTime); }
    bool ShouldJumpOutOfWater(FVector * JumpDir) { return NativeCall<bool, FVector*>(this, "UCharacterMovementComponent.ShouldJumpOutOfWater", JumpDir); }
    void ServerJumpOutOfWater_Implementation(FVector_NetQuantize100 WallNormal, char JumpFlag) { NativeCall<void, FVector_NetQuantize100, char>(this, "UCharacterMovementComponent.ServerJumpOutOfWater_Implementation", WallNormal, JumpFlag); }
    bool CheckWaterJump(FVector CheckPoint, FVector * WallNormal) { return NativeCall<bool, FVector, FVector*>(this, "UCharacterMovementComponent.CheckWaterJump", CheckPoint, WallNormal); }
    void AddImpulse(FVector Impulse, bool bVelocityChange, float MassScaleImpulseExponent, bool bOverrideMaxImpulseZ) { NativeCall<void, FVector, bool, float, bool>(this, "UCharacterMovementComponent.AddImpulse", Impulse, bVelocityChange, MassScaleImpulseExponent, bOverrideMaxImpulseZ); }
    void AddForce(FVector Force) { NativeCall<void, FVector>(this, "UCharacterMovementComponent.AddForce", Force); }
    bool IsWalkable(FHitResult * Hit) { return NativeCall<bool, FHitResult*>(this, "UCharacterMovementComponent.IsWalkable", Hit); }
    void SetWalkableFloorZ(float InWalkableFloorZ) { NativeCall<void, float>(this, "UCharacterMovementComponent.SetWalkableFloorZ", InWalkableFloorZ); }
    bool IsWithinEdgeTolerance(FVector * CapsuleLocation, FVector * TestImpactPoint, const float CapsuleRadius) { return NativeCall<bool, FVector*, FVector*, const float>(this, "UCharacterMovementComponent.IsWithinEdgeTolerance", CapsuleLocation, TestImpactPoint, CapsuleRadius); }
    bool IsValidLandingSpot(FVector * CapsuleLocation, FHitResult * Hit) { return NativeCall<bool, FVector*, FHitResult*>(this, "UCharacterMovementComponent.IsValidLandingSpot", CapsuleLocation, Hit); }
    bool ShouldCheckForValidLandingSpot(float DeltaTime, FVector * Delta, FHitResult * Hit) { return NativeCall<bool, float, FVector*, FHitResult*>(this, "UCharacterMovementComponent.ShouldCheckForValidLandingSpot", DeltaTime, Delta, Hit); }
    float GetPerchRadiusThreshold() { return NativeCall<float>(this, "UCharacterMovementComponent.GetPerchRadiusThreshold"); }
    float GetValidPerchRadius() { return NativeCall<float>(this, "UCharacterMovementComponent.GetValidPerchRadius"); }
    bool ShouldComputePerchResult(FHitResult * InHit, bool bCheckRadius) { return NativeCall<bool, FHitResult*, bool>(this, "UCharacterMovementComponent.ShouldComputePerchResult", InHit, bCheckRadius); }
    bool CanStepUp(FHitResult * Hit) { return NativeCall<bool, FHitResult*>(this, "UCharacterMovementComponent.CanStepUp", Hit); }
    void HandleImpact(FHitResult * Impact, float TimeSlice, FVector * MoveDelta) { NativeCall<void, FHitResult*, float, FVector*>(this, "UCharacterMovementComponent.HandleImpact", Impact, TimeSlice, MoveDelta); }
    void ApplyImpactPhysicsForces(FHitResult * Impact, FVector * ImpactAcceleration, FVector * ImpactVelocity) { NativeCall<void, FHitResult*, FVector*, FVector*>(this, "UCharacterMovementComponent.ApplyImpactPhysicsForces", Impact, ImpactAcceleration, ImpactVelocity); }
    FString * GetMovementName(FString * result) { return NativeCall<FString*, FString*>(this, "UCharacterMovementComponent.GetMovementName", result); }
    void ForceReplicationUpdate() { NativeCall<void>(this, "UCharacterMovementComponent.ForceReplicationUpdate"); }
    FVector * ConstrainInputAcceleration(FVector * result, FVector * InputAcceleration) { return NativeCall<FVector*, FVector*, FVector*>(this, "UCharacterMovementComponent.ConstrainInputAcceleration", result, InputAcceleration); }
    FVector * ScaleInputAcceleration(FVector * result, FVector * InputAcceleration) { return NativeCall<FVector*, FVector*, FVector*>(this, "UCharacterMovementComponent.ScaleInputAcceleration", result, InputAcceleration); }
    float ComputeAnalogInputModifier() { return NativeCall<float>(this, "UCharacterMovementComponent.ComputeAnalogInputModifier"); }
    bool ClientUpdatePositionAfterServerUpdate() { return NativeCall<bool>(this, "UCharacterMovementComponent.ClientUpdatePositionAfterServerUpdate"); }
    void ForcePositionUpdate(float DeltaTime) { NativeCall<void, float>(this, "UCharacterMovementComponent.ForcePositionUpdate", DeltaTime); }
    FNetworkPredictionData_Client * GetPredictionData_Client() { return NativeCall<FNetworkPredictionData_Client*>(this, "UCharacterMovementComponent.GetPredictionData_Client"); }
    FNetworkPredictionData_Server * GetPredictionData_Server() { return NativeCall<FNetworkPredictionData_Server*>(this, "UCharacterMovementComponent.GetPredictionData_Server"); }
    FNetworkPredictionData_Client_Character * GetPredictionData_Client_Character() { return NativeCall<FNetworkPredictionData_Client_Character*>(this, "UCharacterMovementComponent.GetPredictionData_Client_Character"); }
    FNetworkPredictionData_Server_Character * GetPredictionData_Server_Character() { return NativeCall<FNetworkPredictionData_Server_Character*>(this, "UCharacterMovementComponent.GetPredictionData_Server_Character"); }
    void ResetPredictionData_Client() { NativeCall<void>(this, "UCharacterMovementComponent.ResetPredictionData_Client"); }
    void ResetPredictionData_Server() { NativeCall<void>(this, "UCharacterMovementComponent.ResetPredictionData_Server"); }
    void ReplicateMoveToServer(float DeltaTime, FVector * NewAcceleration) { NativeCall<void, float, FVector*>(this, "UCharacterMovementComponent.ReplicateMoveToServer", DeltaTime, NewAcceleration); }
    void ServerMoveOld_Implementation(float OldTimeStamp, FVector_NetQuantize100 OldAccel, char OldMoveFlags) { NativeCall<void, float, FVector_NetQuantize100, char>(this, "UCharacterMovementComponent.ServerMoveOld_Implementation", OldTimeStamp, OldAccel, OldMoveFlags); }
    void ServerMoveWithRotation_Implementation(float TimeStamp, FVector_NetQuantize100 InAccel, FVector_NetQuantize100 ClientLoc, char MoveFlags, char ClientRoll, unsigned int View, UPrimitiveComponent * ClientMovementBase, FName ClientBaseBoneName, char ClientMovementMode, FRotator ClientRotation) { NativeCall<void, float, FVector_NetQuantize100, FVector_NetQuantize100, char, char, unsigned int, UPrimitiveComponent*, FName, char, FRotator>(this, "UCharacterMovementComponent.ServerMoveWithRotation_Implementation", TimeStamp, InAccel, ClientLoc, MoveFlags, ClientRoll, View, ClientMovementBase, ClientBaseBoneName, ClientMovementMode, ClientRotation); }
    void ServerMoveOldWithRotation_Implementation(float OldTimeStamp, FVector_NetQuantize100 OldAccel, char OldMoveFlags, FRotator OldRotation) { NativeCall<void, float, FVector_NetQuantize100, char, FRotator>(this, "UCharacterMovementComponent.ServerMoveOldWithRotation_Implementation", OldTimeStamp, OldAccel, OldMoveFlags, OldRotation); }
    void ServerMoveDualWithRotation_Implementation(float TimeStamp0, FVector_NetQuantize100 InAccel0, char PendingFlags, unsigned int View0, float TimeStamp, FVector_NetQuantize100 InAccel, FVector_NetQuantize100 ClientLoc, char NewFlags, char ClientRoll, unsigned int View, UPrimitiveComponent * ClientMovementBase, FName ClientBaseBone, char ClientMovementMode, FRotator InRotation0, FRotator InRotation) { NativeCall<void, float, FVector_NetQuantize100, char, unsigned int, float, FVector_NetQuantize100, FVector_NetQuantize100, char, char, unsigned int, UPrimitiveComponent*, FName, char, FRotator, FRotator>(this, "UCharacterMovementComponent.ServerMoveDualWithRotation_Implementation", TimeStamp0, InAccel0, PendingFlags, View0, TimeStamp, InAccel, ClientLoc, NewFlags, ClientRoll, View, ClientMovementBase, ClientBaseBone, ClientMovementMode, InRotation0, InRotation); }
    void ServerMoveHandleClientErrorForDinos(float TimeStamp, float DeltaTime, FVector * Accel, FVector * RelativeClientLoc, UPrimitiveComponent * ClientMovementBase, FName ClientBaseBoneName, char ClientMovementMode, FRotator * InClientRot) { NativeCall<void, float, float, FVector*, FVector*, UPrimitiveComponent*, FName, char, FRotator*>(this, "UCharacterMovementComponent.ServerMoveHandleClientErrorForDinos", TimeStamp, DeltaTime, Accel, RelativeClientLoc, ClientMovementBase, ClientBaseBoneName, ClientMovementMode, InClientRot); }
    void ServerMoveDual_Implementation(float TimeStamp0, FVector_NetQuantize100 InAccel0, char PendingFlags, unsigned int View0, float TimeStamp, FVector_NetQuantize100 InAccel, FVector_NetQuantize100 ClientLoc, char NewFlags, char ClientRoll, unsigned int View, UPrimitiveComponent * ClientMovementBase, FName ClientBaseBone, char ClientMovementMode) { NativeCall<void, float, FVector_NetQuantize100, char, unsigned int, float, FVector_NetQuantize100, FVector_NetQuantize100, char, char, unsigned int, UPrimitiveComponent*, FName, char>(this, "UCharacterMovementComponent.ServerMoveDual_Implementation", TimeStamp0, InAccel0, PendingFlags, View0, TimeStamp, InAccel, ClientLoc, NewFlags, ClientRoll, View, ClientMovementBase, ClientBaseBone, ClientMovementMode); }
    bool VerifyClientTimeStamp(float TimeStamp, FNetworkPredictionData_Server_Character * ServerData) { return NativeCall<bool, float, FNetworkPredictionData_Server_Character*>(this, "UCharacterMovementComponent.VerifyClientTimeStamp", TimeStamp, ServerData); }
    void ReadjustClientPositionToCurrent(float TimeStamp, FNetworkPredictionData_Server_Character * ServerData) { NativeCall<void, float, FNetworkPredictionData_Server_Character*>(this, "UCharacterMovementComponent.ReadjustClientPositionToCurrent", TimeStamp, ServerData); }
    bool ProcessClientTimeStamp(float TimeStamp, FNetworkPredictionData_Server_Character * ServerData) { return NativeCall<bool, float, FNetworkPredictionData_Server_Character*>(this, "UCharacterMovementComponent.ProcessClientTimeStamp", TimeStamp, ServerData); }
    void ServerMove_Implementation(float TimeStamp, FVector_NetQuantize100 InAccel, FVector_NetQuantize100 ClientLoc, char MoveFlags, char ClientRoll, unsigned int View, UPrimitiveComponent * ClientMovementBase, FName ClientBaseBoneName, char ClientMovementMode) { NativeCall<void, float, FVector_NetQuantize100, FVector_NetQuantize100, char, char, unsigned int, UPrimitiveComponent*, FName, char>(this, "UCharacterMovementComponent.ServerMove_Implementation", TimeStamp, InAccel, ClientLoc, MoveFlags, ClientRoll, View, ClientMovementBase, ClientBaseBoneName, ClientMovementMode); }
    void ServerMoveHandleClientError(float TimeStamp, float DeltaTime, FVector * Accel, FVector * RelativeClientLoc, UPrimitiveComponent * ClientMovementBase, FName ClientBaseBoneName, char ClientMovementMode) { NativeCall<void, float, float, FVector*, FVector*, UPrimitiveComponent*, FName, char>(this, "UCharacterMovementComponent.ServerMoveHandleClientError", TimeStamp, DeltaTime, Accel, RelativeClientLoc, ClientMovementBase, ClientBaseBoneName, ClientMovementMode); }
    void ServerMoveOnlyRotation_Implementation(float TimeStamp, char ClientRoll, unsigned int View) { NativeCall<void, float, char, unsigned int>(this, "UCharacterMovementComponent.ServerMoveOnlyRotation_Implementation", TimeStamp, ClientRoll, View); }
    void ServerMoveDualOnlyRotation_Implementation(float TimeStamp0, unsigned int View0, float TimeStamp, char ClientRoll, unsigned int View) { NativeCall<void, float, unsigned int, float, char, unsigned int>(this, "UCharacterMovementComponent.ServerMoveDualOnlyRotation_Implementation", TimeStamp0, View0, TimeStamp, ClientRoll, View); }
    void MoveAutonomous(float ClientTimeStamp, float DeltaTime, char CompressedFlags, FVector * NewAccel) { NativeCall<void, float, float, char, FVector*>(this, "UCharacterMovementComponent.MoveAutonomous", ClientTimeStamp, DeltaTime, CompressedFlags, NewAccel); }
    void UpdateFloorFromAdjustment() { NativeCall<void>(this, "UCharacterMovementComponent.UpdateFloorFromAdjustment"); }
    void SendClientAdjustment() { NativeCall<void>(this, "UCharacterMovementComponent.SendClientAdjustment"); }
    void ClientVeryShortAdjustPosition_Implementation(float TimeStamp, FVector NewLoc, UPrimitiveComponent * NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, char ServerMovementMode) { NativeCall<void, float, FVector, UPrimitiveComponent*, FName, bool, bool, char>(this, "UCharacterMovementComponent.ClientVeryShortAdjustPosition_Implementation", TimeStamp, NewLoc, NewBase, NewBaseBoneName, bHasBase, bBaseRelativePosition, ServerMovementMode); }
    void ClientAdjustPosition_Implementation(float TimeStamp, FVector NewLocation, FVector NewVelocity, UPrimitiveComponent * NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, char ServerMovementMode) { NativeCall<void, float, FVector, FVector, UPrimitiveComponent*, FName, bool, bool, char>(this, "UCharacterMovementComponent.ClientAdjustPosition_Implementation", TimeStamp, NewLocation, NewVelocity, NewBase, NewBaseBoneName, bHasBase, bBaseRelativePosition, ServerMovementMode); }
    void ClientAdjustRootMotionPosition_Implementation(float TimeStamp, float ServerMontageTrackPosition, FVector ServerLoc, FVector_NetQuantizeNormal ServerRotation, float ServerVelZ, UPrimitiveComponent * ServerBase, FName ServerBaseBoneName, bool bHasBase, bool bBaseRelativePosition, char ServerMovementMode) { NativeCall<void, float, float, FVector, FVector_NetQuantizeNormal, float, UPrimitiveComponent*, FName, bool, bool, char>(this, "UCharacterMovementComponent.ClientAdjustRootMotionPosition_Implementation", TimeStamp, ServerMontageTrackPosition, ServerLoc, ServerRotation, ServerVelZ, ServerBase, ServerBaseBoneName, bHasBase, bBaseRelativePosition, ServerMovementMode); }
    void ClientAckGoodMove_Implementation(float TimeStamp) { NativeCall<void, float>(this, "UCharacterMovementComponent.ClientAckGoodMove_Implementation", TimeStamp); }
    void CapsuleTouched(AActor * Other, UPrimitiveComponent * OtherComp, int OtherBodyIndex, bool bFromSweep, FHitResult * SweepResult) { NativeCall<void, AActor*, UPrimitiveComponent*, int, bool, FHitResult*>(this, "UCharacterMovementComponent.CapsuleTouched", Other, OtherComp, OtherBodyIndex, bFromSweep, SweepResult); }
    void ApplyRepulsionForce(float DeltaSeconds) { NativeCall<void, float>(this, "UCharacterMovementComponent.ApplyRepulsionForce", DeltaSeconds); }
    void ApplyAccumulatedForces(float DeltaSeconds) { NativeCall<void, float>(this, "UCharacterMovementComponent.ApplyAccumulatedForces", DeltaSeconds); }
    void AddRadialForce(FVector * Origin, float Radius, float Strength, ERadialImpulseFalloff Falloff) { NativeCall<void, FVector*, float, float, ERadialImpulseFalloff>(this, "UCharacterMovementComponent.AddRadialForce", Origin, Radius, Strength, Falloff); }
    void AddRadialImpulse(FVector * Origin, float Radius, float Strength, ERadialImpulseFalloff Falloff, bool bVelChange) { NativeCall<void, FVector*, float, float, ERadialImpulseFalloff, bool>(this, "UCharacterMovementComponent.AddRadialImpulse", Origin, Radius, Strength, Falloff, bVelChange); }
    bool IsFlyingOrControlledFalling() { return NativeCall<bool>(this, "UCharacterMovementComponent.IsFlyingOrControlledFalling"); }
    void RegisterComponentTickFunctions(bool bRegister, bool bSaveAndRestoreComponentTickState) { NativeCall<void, bool, bool>(this, "UCharacterMovementComponent.RegisterComponentTickFunctions", bRegister, bSaveAndRestoreComponentTickState); }
    void TickCharacterPose(float DeltaTime) { NativeCall<void, float>(this, "UCharacterMovementComponent.TickCharacterPose", DeltaTime); }
    void UpdateFromCompressedFlags(char Flags) { NativeCall<void, char>(this, "UCharacterMovementComponent.UpdateFromCompressedFlags", Flags); }
    void Prone(bool bClientSimulation) { NativeCall<void, bool>(this, "UCharacterMovementComponent.Prone", bClientSimulation); }
    void UnProne(bool bClientSimulation, bool bForce) { NativeCall<void, bool, bool>(this, "UCharacterMovementComponent.UnProne", bClientSimulation, bForce); }
    bool IsOnWalkableFloor() { return NativeCall<bool>(this, "UCharacterMovementComponent.IsOnWalkableFloor"); }
    bool ShouldForceDedicatedTickEveryFrame() { return NativeCall<bool>(this, "UCharacterMovementComponent.ShouldForceDedicatedTickEveryFrame"); }
    static void StaticRegisterNativesUCharacterMovementComponent() { NativeCall<void>(nullptr, "UCharacterMovementComponent.StaticRegisterNativesUCharacterMovementComponent"); }
    void ClientAckGoodMove(float TimeStamp) { NativeCall<void, float>(this, "UCharacterMovementComponent.ClientAckGoodMove", TimeStamp); }
    void ClientAdjustPosition(float TimeStamp, FVector NewLoc, FVector NewVel, UPrimitiveComponent * NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, char ServerMovementMode) { NativeCall<void, float, FVector, FVector, UPrimitiveComponent*, FName, bool, bool, char>(this, "UCharacterMovementComponent.ClientAdjustPosition", TimeStamp, NewLoc, NewVel, NewBase, NewBaseBoneName, bHasBase, bBaseRelativePosition, ServerMovementMode); }
    void ClientVeryShortAdjustPosition(float TimeStamp, FVector NewLoc, UPrimitiveComponent * NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, char ServerMovementMode) { NativeCall<void, float, FVector, UPrimitiveComponent*, FName, bool, bool, char>(this, "UCharacterMovementComponent.ClientVeryShortAdjustPosition", TimeStamp, NewLoc, NewBase, NewBaseBoneName, bHasBase, bBaseRelativePosition, ServerMovementMode); }
    void ServerJumpOutOfWater(FVector_NetQuantize100 WallNormal, char JumpFlag) { NativeCall<void, FVector_NetQuantize100, char>(this, "UCharacterMovementComponent.ServerJumpOutOfWater", WallNormal, JumpFlag); }
    void ServerMove(float TimeStamp, FVector_NetQuantize100 InAccel, FVector_NetQuantize100 ClientLoc, char CompressedMoveFlags, char ClientRoll, unsigned int View, UPrimitiveComponent * ClientMovementBase, FName ClientBaseBoneName, char ClientMovementMode) { NativeCall<void, float, FVector_NetQuantize100, FVector_NetQuantize100, char, char, unsigned int, UPrimitiveComponent*, FName, char>(this, "UCharacterMovementComponent.ServerMove", TimeStamp, InAccel, ClientLoc, CompressedMoveFlags, ClientRoll, View, ClientMovementBase, ClientBaseBoneName, ClientMovementMode); }
    void ServerMoveDual(float TimeStamp0, FVector_NetQuantize100 InAccel0, char PendingFlags, unsigned int View0, float TimeStamp, FVector_NetQuantize100 InAccel, FVector_NetQuantize100 ClientLoc, char NewFlags, char ClientRoll, unsigned int View, UPrimitiveComponent * ClientMovementBase, FName ClientBaseBoneName, char ClientMovementMode) { NativeCall<void, float, FVector_NetQuantize100, char, unsigned int, float, FVector_NetQuantize100, FVector_NetQuantize100, char, char, unsigned int, UPrimitiveComponent*, FName, char>(this, "UCharacterMovementComponent.ServerMoveDual", TimeStamp0, InAccel0, PendingFlags, View0, TimeStamp, InAccel, ClientLoc, NewFlags, ClientRoll, View, ClientMovementBase, ClientBaseBoneName, ClientMovementMode); }
    void ServerMoveDualOnlyRotation(float TimeStamp0, unsigned int View0, float TimeStamp, char ClientRoll, unsigned int View) { NativeCall<void, float, unsigned int, float, char, unsigned int>(this, "UCharacterMovementComponent.ServerMoveDualOnlyRotation", TimeStamp0, View0, TimeStamp, ClientRoll, View); }
    void ServerMoveDualWithRotation(float TimeStamp0, FVector_NetQuantize100 InAccel0, char PendingFlags, unsigned int View0, float TimeStamp, FVector_NetQuantize100 InAccel, FVector_NetQuantize100 ClientLoc, char NewFlags, char ClientRoll, unsigned int View, UPrimitiveComponent * ClientMovementBase, FName ClientBaseBoneName, char ClientMovementMode, FRotator InRotation0, FRotator InRotation) { NativeCall<void, float, FVector_NetQuantize100, char, unsigned int, float, FVector_NetQuantize100, FVector_NetQuantize100, char, char, unsigned int, UPrimitiveComponent*, FName, char, FRotator, FRotator>(this, "UCharacterMovementComponent.ServerMoveDualWithRotation", TimeStamp0, InAccel0, PendingFlags, View0, TimeStamp, InAccel, ClientLoc, NewFlags, ClientRoll, View, ClientMovementBase, ClientBaseBoneName, ClientMovementMode, InRotation0, InRotation); }
    void ServerMoveOld(float OldTimeStamp, FVector_NetQuantize100 OldAccel, char OldMoveFlags) { NativeCall<void, float, FVector_NetQuantize100, char>(this, "UCharacterMovementComponent.ServerMoveOld", OldTimeStamp, OldAccel, OldMoveFlags); }
    void ServerMoveOldWithRotation(float OldTimeStamp, FVector_NetQuantize100 OldAccel, char OldMoveFlags, FRotator OldRotation) { NativeCall<void, float, FVector_NetQuantize100, char, FRotator>(this, "UCharacterMovementComponent.ServerMoveOldWithRotation", OldTimeStamp, OldAccel, OldMoveFlags, OldRotation); }
    void ServerMoveOnlyRotation(float TimeStamp, char ClientRoll, unsigned int View) { NativeCall<void, float, char, unsigned int>(this, "UCharacterMovementComponent.ServerMoveOnlyRotation", TimeStamp, ClientRoll, View); }
    void ServerMoveWithRotation(float TimeStamp, FVector_NetQuantize100 InAccel, FVector_NetQuantize100 ClientLoc, char CompressedMoveFlags, char ClientRoll, unsigned int View, UPrimitiveComponent * ClientMovementBase, FName ClientBaseBoneName, char ClientMovementMode, FRotator ClientRotation) { NativeCall<void, float, FVector_NetQuantize100, FVector_NetQuantize100, char, char, unsigned int, UPrimitiveComponent*, FName, char, FRotator>(this, "UCharacterMovementComponent.ServerMoveWithRotation", TimeStamp, InAccel, ClientLoc, CompressedMoveFlags, ClientRoll, View, ClientMovementBase, ClientBaseBoneName, ClientMovementMode, ClientRotation); }
 
    // Enums
 
    enum EServerMoveType
    {
        DefaultMove = 0x0,
        MoveOnlyRotation = 0x1,
    };
 
    enum EShrinkCapsuleExtent
    {
        SHRINK_None = 0x0,
        SHRINK_RadiusCustom = 0x1,
        SHRINK_HeightCustom = 0x2,
        SHRINK_AllCustom = 0x3,
    };
};
 
struct ABrush : AActor
{
 
};
 
struct AVolume : ABrush
{
 
};
 
struct ANPCZoneVolume : AVolume
{
    // Fields
    /*unsigned __int32 bOnlyCountWaterDinos : 1;
    unsigned __int32 bOnlyCountLandDinos : 1;
    unsigned __int32 bCountTamedDinos : 1;
    TArray<TSubclassOf<APrimalDinoCharacter>> OnlyCountDinoClasses;
    TArray<TSubclassOf<APrimalDinoCharacter>> IgnoreDinoClasses;
    TArray<FHibernationCountInfo> HibernatedEntities;
    float HibernatedCountWeights;
    TArray<APrimalDinoCharacter *> OverlappedDinos;
    float CountWeights;*/
};
 
struct ANPCZoneSpawnVolume : AVolume
{
};
 
struct FLinkedZoneSpawnVolumeEntry
{
    // Fields
    /*ANPCZoneSpawnVolume *LinkedZoneSpawnVolume;
    TArray<AActor *> ZoneSpawnVolumeFloors;
    TArray<FName> ZoneSpawnVolumeFloorTags;
    float EntryWeight;*/
};
 
struct AWorldSettings : AInfo
{
};
 
struct APrimalWorldSettings : AWorldSettings
{
    bool& bOverrideLongitudeAndLatitudeField() { return *GetNativePointerField<bool*>(this, "APrimalWorldSettings.bOverrideLongitudeAndLatitude"); }
    float& LongitudeScaleField() { return *GetNativePointerField<float*>(this, "APrimalWorldSettings.LongitudeScale"); }
    float& LatitudeScaleField() { return *GetNativePointerField<float*>(this, "APrimalWorldSettings.LatitudeScale"); }
    float& LongitudeOriginField() { return *GetNativePointerField<float*>(this, "APrimalWorldSettings.LongitudeOrigin"); }
    float& LatitudeOriginField() { return *GetNativePointerField<float*>(this, "APrimalWorldSettings.LatitudeOrigin"); }
    TMap<unsigned int, AActor*>& StructureIDMapField() { return *GetNativePointerField <TMap<unsigned int, AActor*>*>(this, "APrimalWorldSettings.StructureIDMap"); }
};
 
struct ANPCZoneManager
{
    TArray<FLinkedZoneSpawnVolumeEntry>& LinkedZoneSpawnVolumeEntriesField() { return *GetNativePointerField<TArray<FLinkedZoneSpawnVolumeEntry>*>(this, "ANPCZoneManager.LinkedZoneSpawnVolumeEntries"); }
    TArray<AActor *> DefaultZoneSpawnVolumeFloorsField() { return *GetNativePointerField<TArray<AActor *>*>(this, "ANPCZoneManager.DefaultZoneSpawnVolumeFloors"); }
    TArray<FName>& DefaultZoneSpawnVolumeFloorTagsField() { return *GetNativePointerField<TArray<FName>*>(this, "ANPCZoneManager.DefaultZoneSpawnVolumeFloorTags"); }
    TSubclassOf<UNPCSpawnEntriesContainer>& NPCSpawnEntriesContainerObjectField() { return *GetNativePointerField<TSubclassOf<UNPCSpawnEntriesContainer>*>(this, "ANPCZoneManager.NPCSpawnEntriesContainerObject"); }
    bool& bEnabledField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bEnabled"); }
    bool& bForceInEditorField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bForceInEditor"); }
    bool& bNeverSpawnInWaterField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bNeverSpawnInWater"); }
    bool& bOnlySpawnInWaterField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bOnlySpawnInWater"); }
    bool& bAllowExtentTestField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bAllowExtentTest"); }
    bool& bOnlyCheckMySublevelWaterField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bOnlyCheckMySublevelWater"); }
    int& MinDesiredNumberOfNPCField() { return *GetNativePointerField<int*>(this, "ANPCZoneManager.MinDesiredNumberOfNPC"); }
    int& SP_MinDesiredNumberOfNPCField() { return *GetNativePointerField<int*>(this, "ANPCZoneManager.SP_MinDesiredNumberOfNPC"); }
    int& MaxNumberOfNPCField() { return *GetNativePointerField<int*>(this, "ANPCZoneManager.MaxNumberOfNPC"); }
    float& DesiredNumberOfNPCMultiplierField() { return *GetNativePointerField<float*>(this, "ANPCZoneManager.DesiredNumberOfNPCMultiplier"); }
    float& TheSpawnPointMinimumFloorNormalField() { return *GetNativePointerField<float*>(this, "ANPCZoneManager.TheSpawnPointMinimumFloorNormal"); }
    float& TheNewNewEditorNumberOfNPCMultiplierField() { return *GetNativePointerField<float*>(this, "ANPCZoneManager.TheNewNewEditorNumberOfNPCMultiplier"); }
    float& KillOffOverweightNPCStasisTimeField() { return *GetNativePointerField<float*>(this, "ANPCZoneManager.KillOffOverweightNPCStasisTime"); }
    float& TheMaximumWorldTimeForFullIncreaseField() { return *GetNativePointerField<float*>(this, "ANPCZoneManager.TheMaximumWorldTimeForFullIncrease"); }
    float& TheMinimumPlayerDistanceFromSpawnPointField() { return *GetNativePointerField<float*>(this, "ANPCZoneManager.TheMinimumPlayerDistanceFromSpawnPoint"); }
    float& TheIncreaseNPCIntervalField() { return *GetNativePointerField<float*>(this, "ANPCZoneManager.TheIncreaseNPCInterval"); }
    float& SP_TheIncreaseNPCIntervalField() { return *GetNativePointerField<float*>(this, "ANPCZoneManager.SP_TheIncreaseNPCInterval"); }
    float& TheIncreaseNPCIntervalMaxField() { return *GetNativePointerField<float*>(this, "ANPCZoneManager.TheIncreaseNPCIntervalMax"); }
    float& TheDecreaseNPCIntervalField() { return *GetNativePointerField<float*>(this, "ANPCZoneManager.TheDecreaseNPCInterval"); }
    float& NPCAIRangeMultiplierField() { return *GetNativePointerField<float*>(this, "ANPCZoneManager.NPCAIRangeMultiplier"); }
    bool& bNPCDontWanderField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bNPCDontWander"); }
    bool& bNPCWildIgnoreWildField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bNPCWildIgnoreWild"); }
    bool& bNPCNoKillXPField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bNPCNoKillXP"); }
    bool& bNPCPreventSavingField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bNPCPreventSaving"); }
    bool& bForceUntameableField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bForceUntameable"); }
    bool& bUsesManualSpawningField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bUsesManualSpawning"); }
    bool& bIgnoreVolumeEcompassingCheckField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bIgnoreVolumeEcompassingCheck"); }
    bool& bSpawnAllNPCEntriesField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bSpawnAllNPCEntries"); }
    bool& bOnlyUseInSingleplayerField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bOnlyUseInSingleplayer"); }
    bool& bOnlyUseInDedicatedServerField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bOnlyUseInDedicatedServer"); }
    float& NPCWanderRadiusMultiplierField() { return *GetNativePointerField<float*>(this, "ANPCZoneManager.NPCWanderRadiusMultiplier"); }
    int& MaxNumberSpawnZoneRandomPointChecksField() { return *GetNativePointerField<int*>(this, "ANPCZoneManager.MaxNumberSpawnZoneRandomPointChecks"); }
    int& TheNPCFullIncreaseMaximumIterationsField() { return *GetNativePointerField<int*>(this, "ANPCZoneManager.TheNPCFullIncreaseMaximumIterations"); }
    float& TheMinimumTamedDinoDistanceFromSpawnPointField() { return *GetNativePointerField<float*>(this, "ANPCZoneManager.TheMinimumTamedDinoDistanceFromSpawnPoint"); }
    float& TheMinimumStructureDistanceFromSpawnPointField() { return *GetNativePointerField<float*>(this, "ANPCZoneManager.TheMinimumStructureDistanceFromSpawnPoint"); }
    float& NPCLerpToMaxRandomBaseLevelField() { return *GetNativePointerField<float*>(this, "ANPCZoneManager.NPCLerpToMaxRandomBaseLevel"); }
    float& ManualSpawningNPCLerpToMaxRandomBaseLevelField() { return *GetNativePointerField<float*>(this, "ANPCZoneManager.ManualSpawningNPCLerpToMaxRandomBaseLevel"); }
    int& MaximumNumberNearbyCoreStructuresField() { return *GetNativePointerField<int*>(this, "ANPCZoneManager.MaximumNumberNearbyCoreStructures"); }
    int& AbsoluteMaximumNumberNearbyCoreStructuresField() { return *GetNativePointerField<int*>(this, "ANPCZoneManager.AbsoluteMaximumNumberNearbyCoreStructures"); }
    bool& bAutoKillUseGlobalStasisArrayField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bAutoKillUseGlobalStasisArray"); }
    bool& bTraceForSpawnAgainstWaterField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bTraceForSpawnAgainstWater"); }
    bool& bNPCForcePreventExitingWaterField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bNPCForcePreventExitingWater"); }
    bool& bUseSpawnPointOverrideRotationField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bUseSpawnPointOverrideRotation"); }
    float& NPCLevelMultiplierField() { return *GetNativePointerField<float*>(this, "ANPCZoneManager.NPCLevelMultiplier"); }
    int& ForceOverrideNPCBaseLevelField() { return *GetNativePointerField<int*>(this, "ANPCZoneManager.ForceOverrideNPCBaseLevel"); }
    TArray<FNPCSpawnEntry>& NPCSpawnEntriesField() { return *GetNativePointerField<TArray<FNPCSpawnEntry>*>(this, "ANPCZoneManager.NPCSpawnEntries"); }
    TArray<FNPCSpawnLimit>& NPCSpawnLimitsField() { return *GetNativePointerField<TArray<FNPCSpawnLimit>*>(this, "ANPCZoneManager.NPCSpawnLimits"); }
    int& UseDesiredNumberOfNPCField() { return *GetNativePointerField<int*>(this, "ANPCZoneManager.UseDesiredNumberOfNPC"); }
    int& NumNPCSpawnedField() { return *GetNativePointerField<int*>(this, "ANPCZoneManager.NumNPCSpawned"); }
    int& NumSpawnFailuresField() { return *GetNativePointerField<int*>(this, "ANPCZoneManager.NumSpawnFailures"); }
    long double& LastIncreaseNPCTimeField() { return *GetNativePointerField<long double*>(this, "ANPCZoneManager.LastIncreaseNPCTime"); }
    long double& LastDecreaseNPCTimeField() { return *GetNativePointerField<long double*>(this, "ANPCZoneManager.LastDecreaseNPCTime"); }
    bool& bForceRespawnDinosField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bForceRespawnDinos"); }
    bool& bTriedFullIncreaseField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bTriedFullIncrease"); }
    bool& bSpawnsWaterDinosField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bSpawnsWaterDinos"); }
    bool& bSpawnsAmphibiousDinosField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bSpawnsAmphibiousDinos"); }
    float& TheNextIncreaseNPCIntervalField() { return *GetNativePointerField<float*>(this, "ANPCZoneManager.TheNextIncreaseNPCInterval"); }
    float& CloseStructureDistanceFromSpawnPointField() { return *GetNativePointerField<float*>(this, "ANPCZoneManager.CloseStructureDistanceFromSpawnPoint"); }
    TArray<AActor *> SpawnPointOverridesField() { return *GetNativePointerField<TArray<AActor *>*>(this, "ANPCZoneManager.SpawnPointOverrides"); }
    FName& NonDedicatedFreezeWildDinoPhysicsIfLevelUnloadedField() { return *GetNativePointerField<FName*>(this, "ANPCZoneManager.NonDedicatedFreezeWildDinoPhysicsIfLevelUnloaded"); }
    TArray<FName>& NonDedicatedFreezeWildDinoPhysicsIfLevelsUnloadedField() { return *GetNativePointerField<TArray<FName>*>(this, "ANPCZoneManager.NonDedicatedFreezeWildDinoPhysicsIfLevelsUnloaded"); }
    float& MinimumManualSpawnIntervalField() { return *GetNativePointerField<float*>(this, "ANPCZoneManager.MinimumManualSpawnInterval"); }
    long double& LastManuallySpawnedTimeField() { return *GetNativePointerField<long double*>(this, "ANPCZoneManager.LastManuallySpawnedTime"); }
    bool& bIgnoreNPCRandomClassReplacementsField() { return *GetNativePointerField<bool*>(this, "ANPCZoneManager.bIgnoreNPCRandomClassReplacements"); }
    int& TheNPCDynamicIncreaseMaximumIterationsField() { return *GetNativePointerField<int*>(this, "ANPCZoneManager.TheNPCDynamicIncreaseMaximumIterations"); }
 
    // Functions
 
    void BeginPlay() { NativeCall<void>(this, "ANPCZoneManager.BeginPlay"); }
    int GetNumberOfNPCTouching() { return NativeCall<int>(this, "ANPCZoneManager.GetNumberOfNPCTouching"); }
    int GetNumberOfClassNPCTouching(TSubclassOf<APrimalDinoCharacter> ADinoClass) { return NativeCall<int, TSubclassOf<APrimalDinoCharacter>>(this, "ANPCZoneManager.GetNumberOfClassNPCTouching", ADinoClass); }
    void CheckDecreaseNPC() { NativeCall<void>(this, "ANPCZoneManager.CheckDecreaseNPC"); }
    void CheckIncreaseNPC() { NativeCall<void>(this, "ANPCZoneManager.CheckIncreaseNPC"); }
    bool SpawnNPCs() { return NativeCall<bool>(this, "ANPCZoneManager.SpawnNPCs"); }
    bool IsValidNPCEntry(FNPCSpawnEntry * NPCEntry) { return NativeCall<bool, FNPCSpawnEntry *>(this, "ANPCZoneManager.IsValidNPCEntry", NPCEntry); }
    void Report(TMap<UClass *, int, FDefaultSetAllocator, TDefaultMapKeyFuncs<UClass *, int, 0> > * DinoGroups) { NativeCall<void, TMap<UClass *, int, FDefaultSetAllocator, TDefaultMapKeyFuncs<UClass *, int, 0> > *>(this, "ANPCZoneManager.Report", DinoGroups); }
    APrimalDinoCharacter * SpawnFromEntries(int SpawnVolumeEntry, TArray<FNPCSpawnEntry> * spawnEntries, FVector * AtSpawnPoint, TArray<APrimalDinoCharacter *> * AllSpawnedNPCs, float OverrideYaw) { return NativeCall<APrimalDinoCharacter *, int, TArray<FNPCSpawnEntry> *, FVector *, TArray<APrimalDinoCharacter *> *, float>(this, "ANPCZoneManager.SpawnFromEntries", SpawnVolumeEntry, spawnEntries, AtSpawnPoint, AllSpawnedNPCs, OverrideYaw); }
    int FindLinkedSpawnVolumeEntryContainingPoint(FVector AtPoint) { return NativeCall<int, FVector>(this, "ANPCZoneManager.FindLinkedSpawnVolumeEntryContainingPoint", AtPoint); }
    bool GetValidSpawnPoint(int volumeEntryIndex, FVector extentCheck, FVector * ValidSpawnPoint, FVector * OverrideStartPoint, float OverrideStartPointExpansionRadius, float WaterOnlySpawnMinimumWaterHeight, float MaximumWaterHeight, float SpawnMinDistanceFromStructuresMultiplier, float SpawnMinDistanceFromPlayersMultiplier, float SpawnMinDistanceFromTamedDinosMultiplier, float * OverrideYawOut) { return NativeCall<bool, int, FVector, FVector *, FVector *, float, float, float, float, float, float, float *>(this, "ANPCZoneManager.GetValidSpawnPoint", volumeEntryIndex, extentCheck, ValidSpawnPoint, OverrideStartPoint, OverrideStartPointExpansionRadius, WaterOnlySpawnMinimumWaterHeight, MaximumWaterHeight, SpawnMinDistanceFromStructuresMultiplier, SpawnMinDistanceFromPlayersMultiplier, SpawnMinDistanceFromTamedDinosMultiplier, OverrideYawOut); }
    APrimalDinoCharacter * SpawnNPC(TSubclassOf<APrimalDinoCharacter> PawnTemplate, FVector SpawnLoc, bool bOverrideNPCLevel, int NPCLevelOffset, float NPCLevelMultiplier, bool bAddLevelOffsetBeforeMultiplier, float WaterOnlySpawnMinimumWaterHeight, float SpawnVolumeStartExtentZ, float OverrideYaw, float MaximumWaterHeight) { return NativeCall<APrimalDinoCharacter *, TSubclassOf<APrimalDinoCharacter>, FVector, bool, int, float, bool, float, float, float, float>(this, "ANPCZoneManager.SpawnNPC", PawnTemplate, SpawnLoc, bOverrideNPCLevel, NPCLevelOffset, NPCLevelMultiplier, bAddLevelOffsetBeforeMultiplier, WaterOnlySpawnMinimumWaterHeight, SpawnVolumeStartExtentZ, OverrideYaw, MaximumWaterHeight); }
    APrimalDinoCharacter * GetBestNPCToAutoKill() { return NativeCall<APrimalDinoCharacter *>(this, "ANPCZoneManager.GetBestNPCToAutoKill"); }
    void EndPlay(EEndPlayReason::Type EndPlayReason) { NativeCall<void, EEndPlayReason::Type>(this, "ANPCZoneManager.EndPlay", EndPlayReason); }
    static TArray<APrimalDinoCharacter *> * StaticSpawnNPCs(TArray<APrimalDinoCharacter *> * result, UObject * WorldContext, ANPCZoneManager * AtZoneManager, TSubclassOf<UNPCSpawnEntriesContainer> TheNPCSpawnEntries, FVector AtSpawnPoint, FRotator AtRotation, int UseSpawnVolumeIndex) { return NativeCall<TArray<APrimalDinoCharacter *> *, TArray<APrimalDinoCharacter *> *, UObject *, ANPCZoneManager *, TSubclassOf<UNPCSpawnEntriesContainer>, FVector, FRotator, int>(nullptr, "ANPCZoneManager.StaticSpawnNPCs", result, WorldContext, AtZoneManager, TheNPCSpawnEntries, AtSpawnPoint, AtRotation, UseSpawnVolumeIndex); }
    static void StaticRegisterNativesANPCZoneManager() { NativeCall<void>(nullptr, "ANPCZoneManager.StaticRegisterNativesANPCZoneManager"); }
    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "ANPCZoneManager.GetPrivateStaticClass"); }
};
 
struct AShooterProjectile : AActor
{
    TWeakObjectPtr<AActor>& DamageCauserField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "AShooterProjectile.DamageCauser"); }
    // Functions 
 
    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "AShooterProjectile.GetPrivateStaticClass"); }
};
 
struct APrimalBuff : AActor
{
    float& DeactivationLifespanField() { return *GetNativePointerField<float*>(this, "APrimalBuff.DeactivationLifespan"); }
    FName& InstigatorAttachmentSocketField() { return *GetNativePointerField<FName*>(this, "APrimalBuff.InstigatorAttachmentSocket"); }
    float& RemoteForcedFleeDurationField() { return *GetNativePointerField<float*>(this, "APrimalBuff.RemoteForcedFleeDuration"); }
    FVector& AoETraceToTargetsStartOffsetField() { return *GetNativePointerField<FVector*>(this, "APrimalBuff.AoETraceToTargetsStartOffset"); }
    TWeakObjectPtr<AActor>& TargetField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "APrimalBuff.Target"); }
    TWeakObjectPtr<UPrimalItem>& InstigatorItemField() { return *GetNativePointerField<TWeakObjectPtr<UPrimalItem>*>(this, "APrimalBuff.InstigatorItem"); }
    float& SlowInstigatorFallingAddZVelocityField() { return *GetNativePointerField<float*>(this, "APrimalBuff.SlowInstigatorFallingAddZVelocity"); }
    float& SlowInstigatorFallingDampenZVelocityField() { return *GetNativePointerField<float*>(this, "APrimalBuff.SlowInstigatorFallingDampenZVelocity"); }
    float& DeactivateAfterTimeField() { return *GetNativePointerField<float*>(this, "APrimalBuff.DeactivateAfterTime"); }
    float& WeaponRecoilMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalBuff.WeaponRecoilMultiplier"); }
    float& ReceiveDamageMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalBuff.ReceiveDamageMultiplier"); }
    float& MeleeDamageMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalBuff.MeleeDamageMultiplier"); }
    float& DepleteInstigatorItemDurabilityPerSecondField() { return *GetNativePointerField<float*>(this, "APrimalBuff.DepleteInstigatorItemDurabilityPerSecond"); }
    FieldArray<float, 12> ValuesToAddPerSecondField() { return { this, "APrimalBuff.ValuesToAddPerSecond" }; }
    FStatusValueModifierDescription& BuffDescriptionField() { return *GetNativePointerField<FStatusValueModifierDescription*>(this, "APrimalBuff.BuffDescription"); }
    float& CharacterAdd_DefaultHyperthermicInsulationField() { return *GetNativePointerField<float*>(this, "APrimalBuff.CharacterAdd_DefaultHyperthermicInsulation"); }
    float& CharacterAdd_DefaultHypothermicInsulationField() { return *GetNativePointerField<float*>(this, "APrimalBuff.CharacterAdd_DefaultHypothermicInsulation"); }
    float& CharacterMultiplier_ExtraWaterConsumptionMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalBuff.CharacterMultiplier_ExtraWaterConsumptionMultiplier"); }
    float& CharacterMultiplier_ExtraFoodConsumptionMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalBuff.CharacterMultiplier_ExtraFoodConsumptionMultiplier"); }
    float& CharacterMultiplier_SubmergedOxygenDecreaseSpeedField() { return *GetNativePointerField<float*>(this, "APrimalBuff.CharacterMultiplier_SubmergedOxygenDecreaseSpeed"); }
    float& ViewMinExposureMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalBuff.ViewMinExposureMultiplier"); }
    float& ViewMaxExposureMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalBuff.ViewMaxExposureMultiplier"); }
    float& XPtoAddField() { return *GetNativePointerField<float*>(this, "APrimalBuff.XPtoAdd"); }
    float& XPtoAddRateField() { return *GetNativePointerField<float*>(this, "APrimalBuff.XPtoAddRate"); }
    bool& bDeactivateAfterAddingXPField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bDeactivateAfterAddingXP"); }
    int& DinoColorizationPriorityField() { return *GetNativePointerField<int*>(this, "APrimalBuff.DinoColorizationPriority"); }
    float& DinoColorizationInterpSpeedField() { return *GetNativePointerField<float*>(this, "APrimalBuff.DinoColorizationInterpSpeed"); }
    FieldArray<FLinearColor, 6> DesiredDinoColorsField() { return { this, "APrimalBuff.DesiredDinoColors" }; }
    float& SubmergedMaxSpeedModifierField() { return *GetNativePointerField<float*>(this, "APrimalBuff.SubmergedMaxSpeedModifier"); }
    float& UnsubmergedMaxSpeedModifierField() { return *GetNativePointerField<float*>(this, "APrimalBuff.UnsubmergedMaxSpeedModifier"); }
    TArray<FDamagePrimalCharacterStatusValueModifier>& CharacterStatusValueModifiersField() { return *GetNativePointerField<TArray<FDamagePrimalCharacterStatusValueModifier>*>(this, "APrimalBuff.CharacterStatusValueModifiers"); }
    long double& BuffStartTimeField() { return *GetNativePointerField<long double*>(this, "APrimalBuff.BuffStartTime"); }
    UMaterialInterface* BuffPostProcessEffectField() { return *GetNativePointerField<UMaterialInterface**>(this, "APrimalBuff.BuffPostProcessEffect"); }
    TArray<TSubclassOf<AActor>>& PreventActorClassesTargetingField() { return *GetNativePointerField<TArray<TSubclassOf<AActor>>*>(this, "APrimalBuff.PreventActorClassesTargeting"); }
    TArray<float>& PreventActorClassesTargetingRangesField() { return *GetNativePointerField<TArray<float>*>(this, "APrimalBuff.PreventActorClassesTargetingRanges"); }
    float& PreventIfMovementMassGreaterThanField() { return *GetNativePointerField<float*>(this, "APrimalBuff.PreventIfMovementMassGreaterThan"); }
    TSubclassOf<APrimalBuff>& AOEOtherBuffToApplyField() { return *GetNativePointerField<TSubclassOf<APrimalBuff>*>(this, "APrimalBuff.AOEOtherBuffToApply"); }
    float& AOEBuffRangeField() { return *GetNativePointerField<float*>(this, "APrimalBuff.AOEBuffRange"); }
    float& CharacterAOEBuffDamageField() { return *GetNativePointerField<float*>(this, "APrimalBuff.CharacterAOEBuffDamage"); }
    float& CharacterAOEBuffResistanceField() { return *GetNativePointerField<float*>(this, "APrimalBuff.CharacterAOEBuffResistance"); }
    float& Maximum2DVelocityForStaminaRecoveryField() { return *GetNativePointerField<float*>(this, "APrimalBuff.Maximum2DVelocityForStaminaRecovery"); }
    TArray<UMaterialInterface*> PostprocessBlendablesToExcludeField() { return *GetNativePointerField<TArray<UMaterialInterface*>*>(this, "APrimalBuff.PostprocessBlendablesToExclude"); }
    TArray<TWeakObjectPtr<APrimalCharacter>>& BuffedCharactersField() { return *GetNativePointerField<TArray<TWeakObjectPtr<APrimalCharacter>>*>(this, "APrimalBuff.BuffedCharacters"); }
    long double& LastItemDurabilityDepletionTimeField() { return *GetNativePointerField<long double*>(this, "APrimalBuff.LastItemDurabilityDepletionTime"); }
    TSubclassOf<APrimalBuff>& BuffToGiveOnDeactivationField() { return *GetNativePointerField<TSubclassOf<APrimalBuff>*>(this, "APrimalBuff.BuffToGiveOnDeactivation"); }
    TArray<TSubclassOf<APrimalBuff>>& BuffClassesToCancelOnActivationField() { return *GetNativePointerField<TArray<TSubclassOf<APrimalBuff>>*>(this, "APrimalBuff.BuffClassesToCancelOnActivation"); }
    TArray<TSubclassOf<APrimalBuff>>& ActivePreventsBuffClassesField() { return *GetNativePointerField<TArray<TSubclassOf<APrimalBuff>>*>(this, "APrimalBuff.ActivePreventsBuffClasses"); }
    TArray<TSubclassOf<APrimalCharacter>>& BuffRequiresOwnerClassField() { return *GetNativePointerField<TArray<TSubclassOf<APrimalCharacter>>*>(this, "APrimalBuff.BuffRequiresOwnerClass"); }
    TArray<TSubclassOf<APrimalCharacter>>& BuffPreventsOwnerClassField() { return *GetNativePointerField<TArray<TSubclassOf<APrimalCharacter>>*>(this, "APrimalBuff.BuffPreventsOwnerClass"); }
    float& XPEarningMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalBuff.XPEarningMultiplier"); }
    bool& bUseBPSetupForInstigatorField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bUseBPSetupForInstigator"); }
    bool& bUseBPDeactivatedField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bUseBPDeactivated"); }
    bool& bUseBPOverrideBuffToGiveOnDeactivationField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bUseBPOverrideBuffToGiveOnDeactivation"); }
    bool& bUseBPCustomAllowAddBuffField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bUseBPCustomAllowAddBuff"); }
    FVector& staticPathingDestinationField() { return *GetNativePointerField<FVector*>(this, "APrimalBuff.staticPathingDestination"); }
    long double& TickingDeactivationTimeField() { return *GetNativePointerField<long double*>(this, "APrimalBuff.TickingDeactivationTime"); }
    UPrimalBuffPersistentData* MyBuffPersistentDataField() { return *GetNativePointerField<UPrimalBuffPersistentData**>(this, "APrimalBuff.MyBuffPersistentData"); }
    TSubclassOf<UPrimalBuffPersistentData>& BuffPersistentDataClassField() { return *GetNativePointerField<TSubclassOf<UPrimalBuffPersistentData>*>(this, "APrimalBuff.BuffPersistentDataClass"); }
    TArray<FMaxStatScaler>& MaxStatScalersField() { return *GetNativePointerField<TArray<FMaxStatScaler>*>(this, "APrimalBuff.MaxStatScalers"); }
    TWeakObjectPtr<AActor>& DamageCauserField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "APrimalBuff.DamageCauser"); }
    USoundBase* ExtraActivationSoundToPlayField() { return *GetNativePointerField<USoundBase**>(this, "APrimalBuff.ExtraActivationSoundToPlay"); }
    bool& bPersistentBuffSurvivesLevelUpField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bPersistentBuffSurvivesLevelUp"); }
    float& AoEApplyDamageField() { return *GetNativePointerField<float*>(this, "APrimalBuff.AoEApplyDamage"); }
    float& AoEApplyDamageIntervalField() { return *GetNativePointerField<float*>(this, "APrimalBuff.AoEApplyDamageInterval"); }
    TSubclassOf<UDamageType>& AoEApplyDamageTypeField() { return *GetNativePointerField<TSubclassOf<UDamageType>*>(this, "APrimalBuff.AoEApplyDamageType"); }
    TSubclassOf<APrimalBuff>& ForceNetworkSpatializationMaxLimitBuffTypeField() { return *GetNativePointerField<TSubclassOf<APrimalBuff>*>(this, "APrimalBuff.ForceNetworkSpatializationMaxLimitBuffType"); }
    int& ForceNetworkSpatializationBuffMaxLimitNumField() { return *GetNativePointerField<int*>(this, "APrimalBuff.ForceNetworkSpatializationBuffMaxLimitNum"); }
    float& ForceNetworkSpatializationBuffMaxLimitRangeField() { return *GetNativePointerField<float*>(this, "APrimalBuff.ForceNetworkSpatializationBuffMaxLimitRange"); }
    float& InsulationRangeField() { return *GetNativePointerField<float*>(this, "APrimalBuff.InsulationRange"); }
    float& HyperThermiaInsulationField() { return *GetNativePointerField<float*>(this, "APrimalBuff.HyperThermiaInsulation"); }
    float& HypoThermiaInsulationField() { return *GetNativePointerField<float*>(this, "APrimalBuff.HypoThermiaInsulation"); }
    FVector& AoEBuffLocOffsetField() { return *GetNativePointerField<FVector*>(this, "APrimalBuff.AoEBuffLocOffset"); }
    TArray<TSubclassOf<AActor>>& AoEClassesToIncludeField() { return *GetNativePointerField<TArray<TSubclassOf<AActor>>*>(this, "APrimalBuff.AoEClassesToInclude"); }
    TArray<TSubclassOf<AActor>>& AoEClassesToExcludeField() { return *GetNativePointerField<TArray<TSubclassOf<AActor>>*>(this, "APrimalBuff.AoEClassesToExclude"); }
    bool& bUseBPExcludeAoEActorField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bUseBPExcludeAoEActor"); }
    bool& bOverrideBuffDescriptionField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bOverrideBuffDescription"); }
    bool& bOnlyTickWhenPossessedField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bOnlyTickWhenPossessed"); }
    bool& bDestroyWhenUnpossessedField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bDestroyWhenUnpossessed"); }
    long double& LastAoEApplyDamageTimeField() { return *GetNativePointerField<long double*>(this, "APrimalBuff.LastAoEApplyDamageTime"); }
    float& OnlyForInstigatorSoundFadeInTimeField() { return *GetNativePointerField<float*>(this, "APrimalBuff.OnlyForInstigatorSoundFadeInTime"); }
    bool& bUseBuffTickServerField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bUseBuffTickServer"); }
    bool& bUseBuffTickClientField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bUseBuffTickClient"); }
    float& BuffTickServerMaxTimeField() { return *GetNativePointerField<float*>(this, "APrimalBuff.BuffTickServerMaxTime"); }
    float& BuffTickServerMinTimeField() { return *GetNativePointerField<float*>(this, "APrimalBuff.BuffTickServerMinTime"); }
    float& BuffTickClientMaxTimeField() { return *GetNativePointerField<float*>(this, "APrimalBuff.BuffTickClientMaxTime"); }
    float& BuffTickClientMinTimeField() { return *GetNativePointerField<float*>(this, "APrimalBuff.BuffTickClientMinTime"); }
    bool& bContinueTickingServerAfterDeactivateField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bContinueTickingServerAfterDeactivate"); }
    bool& bContinueTickingClientAfterDeactivateField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bContinueTickingClientAfterDeactivate"); }
    long double& LastBuffTickTimeServerField() { return *GetNativePointerField<long double*>(this, "APrimalBuff.LastBuffTickTimeServer"); }
    long double& LastBuffTickTimeClientField() { return *GetNativePointerField<long double*>(this, "APrimalBuff.LastBuffTickTimeClient"); }
    long double& NextBuffTickTimeServerField() { return *GetNativePointerField<long double*>(this, "APrimalBuff.NextBuffTickTimeServer"); }
    long double& NextBuffTickTimeClientField() { return *GetNativePointerField<long double*>(this, "APrimalBuff.NextBuffTickTimeClient"); }
    bool& bTickFunctionDisabledField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bTickFunctionDisabled"); }
    bool& bWasStasisedField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bWasStasised"); }
    int& AddBuffMaxNumStacksField() { return *GetNativePointerField<int*>(this, "APrimalBuff.AddBuffMaxNumStacks"); }
    USoundBase* DeactivatedSoundField() { return *GetNativePointerField<USoundBase**>(this, "APrimalBuff.DeactivatedSound"); }
    bool& bDeactivatedSoundOnlyLocalField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bDeactivatedSoundOnlyLocal"); }
    bool& bDisableBloomField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bDisableBloom"); }
    bool& bBPOverrideCharacterNewFallVelocityField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bBPOverrideCharacterNewFallVelocity"); }
    bool& bForceOverrideCharacterNewFallVelocityField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bForceOverrideCharacterNewFallVelocity"); }
    bool& bBPModifyCharacterFOVField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bBPModifyCharacterFOV"); }
    bool& bDisableLightShaftsField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bDisableLightShafts"); }
    float& PostProcessInterpSpeedDownField() { return *GetNativePointerField<float*>(this, "APrimalBuff.PostProcessInterpSpeedDown"); }
    float& PostProcessInterpSpeedUpField() { return *GetNativePointerField<float*>(this, "APrimalBuff.PostProcessInterpSpeedUp"); }
    float& TPVCameraSpeedInterpolationMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalBuff.TPVCameraSpeedInterpolationMultiplier"); }
    bool& bIsCarryBuffField() { return *GetNativePointerField<bool*>(this, "APrimalBuff.bIsCarryBuff"); }
    TArray<FPostProcessMaterialAdjuster>& PostprocessMaterialAdjustersField() { return *GetNativePointerField<TArray<FPostProcessMaterialAdjuster>*>(this, "APrimalBuff.PostprocessMaterialAdjusters"); }
    long double& TimeForNextAOECheckField() { return *GetNativePointerField<long double*>(this, "APrimalBuff.TimeForNextAOECheck"); }
    float& AOEBuffIntervalMinField() { return *GetNativePointerField<float*>(this, "APrimalBuff.AOEBuffIntervalMin"); }
    float& AOEBuffIntervalMaxField() { return *GetNativePointerField<float*>(this, "APrimalBuff.AOEBuffIntervalMax"); }
    float& MaximumVelocityZForSlowingFallField() { return *GetNativePointerField<float*>(this, "APrimalBuff.MaximumVelocityZForSlowingFall"); }
    int& FNameIntField() { return *GetNativePointerField<int*>(this, "APrimalBuff.FNameInt"); }
 
    // Bit fields
 
    BitFieldValue<bool, unsigned __int32> bSlowInstigatorFalling() { return { this, "APrimalBuff.bSlowInstigatorFalling" }; }
    BitFieldValue<bool, unsigned __int32> bDeactivateOnJump() { return { this, "APrimalBuff.bDeactivateOnJump" }; }
    BitFieldValue<bool, unsigned __int32> bPreventJump() { return { this, "APrimalBuff.bPreventJump" }; }
    BitFieldValue<bool, unsigned __int32> bPreventDinoRiding() { return { this, "APrimalBuff.bPreventDinoRiding" }; }
    BitFieldValue<bool, unsigned __int32> bPreventDinoDismount() { return { this, "APrimalBuff.bPreventDinoDismount" }; }
    BitFieldValue<bool, unsigned __int32> bPreventCarryOrPassenger() { return { this, "APrimalBuff.bPreventCarryOrPassenger" }; }
    BitFieldValue<bool, unsigned __int32> bDeactivated() { return { this, "APrimalBuff.bDeactivated" }; }
    BitFieldValue<bool, unsigned __int32> bUsesInstigator() { return { this, "APrimalBuff.bUsesInstigator" }; }
    BitFieldValue<bool, unsigned __int32> bFollowTarget() { return { this, "APrimalBuff.bFollowTarget" }; }
    BitFieldValue<bool, unsigned __int32> bAddCharacterValues() { return { this, "APrimalBuff.bAddCharacterValues" }; }
    BitFieldValue<bool, unsigned __int32> bOnlyAddCharacterValuesUnderwater() { return { this, "APrimalBuff.bOnlyAddCharacterValuesUnderwater" }; }
    BitFieldValue<bool, unsigned __int32> bDisableIfCharacterUnderwater() { return { this, "APrimalBuff.bDisableIfCharacterUnderwater" }; }
    BitFieldValue<bool, unsigned __int32> bUseInstigatorItem() { return { this, "APrimalBuff.bUseInstigatorItem" }; }
    BitFieldValue<bool, unsigned __int32> bDestroyOnTargetStasis() { return { this, "APrimalBuff.bDestroyOnTargetStasis" }; }
    BitFieldValue<bool, unsigned __int32> bAoETraceToTargets() { return { this, "APrimalBuff.bAoETraceToTargets" }; }
    BitFieldValue<bool, unsigned __int32> bAOEOnlyApplyOtherBuffToWildDinos() { return { this, "APrimalBuff.bAOEOnlyApplyOtherBuffToWildDinos" }; }
    BitFieldValue<bool, unsigned __int32> bAoEIgnoreDinosTargetingInstigator() { return { this, "APrimalBuff.bAoEIgnoreDinosTargetingInstigator" }; }
    BitFieldValue<bool, unsigned __int32> bAoEOnlyOnDinosTargetingInstigator() { return { this, "APrimalBuff.bAoEOnlyOnDinosTargetingInstigator" }; }
    BitFieldValue<bool, unsigned __int32> bBuffForceNoTick() { return { this, "APrimalBuff.bBuffForceNoTick" }; }
    BitFieldValue<bool, unsigned __int32> bBuffForceNoTickDedicated() { return { this, "APrimalBuff.bBuffForceNoTickDedicated" }; }
    BitFieldValue<bool, unsigned __int32> bCustomDepthStencilIgnoreHealth() { return { this, "APrimalBuff.bCustomDepthStencilIgnoreHealth" }; }
    BitFieldValue<bool, unsigned __int32> bUseActivateSoundFadeInDuration() { return { this, "APrimalBuff.bUseActivateSoundFadeInDuration" }; }
    BitFieldValue<bool, unsigned __int32> bDinoIgnoreBuffPostprocessEffectWhenRidden() { return { this, "APrimalBuff.bDinoIgnoreBuffPostprocessEffectWhenRidden" }; }
    BitFieldValue<bool, unsigned __int32> bPlayerIgnoreBuffPostprocessEffectWhenRidingDino() { return { this, "APrimalBuff.bPlayerIgnoreBuffPostprocessEffectWhenRidingDino" }; }
    BitFieldValue<bool, unsigned __int32> bRemoteForcedFlee() { return { this, "APrimalBuff.bRemoteForcedFlee" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPDinoRefreshColorization() { return { this, "APrimalBuff.bUseBPDinoRefreshColorization" }; }
    BitFieldValue<bool, unsigned __int32> bOnlyActivateSoundForInstigator() { return { this, "APrimalBuff.bOnlyActivateSoundForInstigator" }; }
    BitFieldValue<bool, unsigned __int32> bAOEBuffCarnosOnly() { return { this, "APrimalBuff.bAOEBuffCarnosOnly" }; }
    BitFieldValue<bool, unsigned __int32> bCausesCryoSickness() { return { this, "APrimalBuff.bCausesCryoSickness" }; }
    BitFieldValue<bool, unsigned __int32> bModifyMaxSpeed() { return { this, "APrimalBuff.bModifyMaxSpeed" }; }
    BitFieldValue<bool, unsigned __int32> bDisplayHUDProgressBar() { return { this, "APrimalBuff.bDisplayHUDProgressBar" }; }
    BitFieldValue<bool, unsigned __int32> bForceUsePreventTargeting() { return { this, "APrimalBuff.bForceUsePreventTargeting" }; }
    BitFieldValue<bool, unsigned __int32> bForceUsePreventTargetingTurret() { return { this, "APrimalBuff.bForceUsePreventTargetingTurret" }; }
    BitFieldValue<bool, unsigned __int32> bBPOverrideWeaponBob() { return { this, "APrimalBuff.bBPOverrideWeaponBob" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPModifyPlayerBoneModifiers() { return { this, "APrimalBuff.bUseBPModifyPlayerBoneModifiers" }; }
    BitFieldValue<bool, unsigned __int32> bDediServerUseBPModifyPlayerBoneModifiers() { return { this, "APrimalBuff.bDediServerUseBPModifyPlayerBoneModifiers" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPNonDedicatedPlayerPostAnimUpdate() { return { this, "APrimalBuff.bUseBPNonDedicatedPlayerPostAnimUpdate" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPIsCharacterHardAttached() { return { this, "APrimalBuff.bUseBPIsCharacterHardAttached" }; }
    BitFieldValue<bool, unsigned __int32> bDoCharacterDetachment() { return { this, "APrimalBuff.bDoCharacterDetachment" }; }
    BitFieldValue<bool, unsigned __int32> bDoCharacterDetachmentIncludeRiding() { return { this, "APrimalBuff.bDoCharacterDetachmentIncludeRiding" }; }
    BitFieldValue<bool, unsigned __int32> bDoCharacterDetachmentIncludeCarrying() { return { this, "APrimalBuff.bDoCharacterDetachmentIncludeCarrying" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPInitializedCharacterAnimScriptInstance() { return { this, "APrimalBuff.bUseBPInitializedCharacterAnimScriptInstance" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPCanBeCarried() { return { this, "APrimalBuff.bUseBPCanBeCarried" }; }
    BitFieldValue<bool, unsigned __int32> bUsePostAdjustDamage() { return { this, "APrimalBuff.bUsePostAdjustDamage" }; }
    BitFieldValue<bool, unsigned __int32> bPreventFallDamage() { return { this, "APrimalBuff.bPreventFallDamage" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOnInstigatorCapsuleComponentHit() { return { this, "APrimalBuff.bUseBPOnInstigatorCapsuleComponentHit" }; }
    BitFieldValue<bool, unsigned __int32> bEnabledCollisionNotify() { return { this, "APrimalBuff.bEnabledCollisionNotify" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOverrideCameraViewTarget() { return { this, "APrimalBuff.bUseBPOverrideCameraViewTarget" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPIsValidUnstasisActor() { return { this, "APrimalBuff.bUseBPIsValidUnstasisActor" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOverrideIsNetRelevantFor() { return { this, "APrimalBuff.bUseBPOverrideIsNetRelevantFor" }; }
    BitFieldValue<bool, unsigned __int32> bPreventClearRiderOnDinoImmobilize() { return { this, "APrimalBuff.bPreventClearRiderOnDinoImmobilize" }; }
    BitFieldValue<bool, unsigned __int32> bAOEApplyOtherBuffOnPlayers() { return { this, "APrimalBuff.bAOEApplyOtherBuffOnPlayers" }; }
    BitFieldValue<bool, unsigned __int32> bAOEApplyOtherBuffOnDinos() { return { this, "APrimalBuff.bAOEApplyOtherBuffOnDinos" }; }
    BitFieldValue<bool, unsigned __int32> bAOEApplyOtherBuffIgnoreSameTeam() { return { this, "APrimalBuff.bAOEApplyOtherBuffIgnoreSameTeam" }; }
    BitFieldValue<bool, unsigned __int32> bAOEApplyOtherBuffRequireSameTeam() { return { this, "APrimalBuff.bAOEApplyOtherBuffRequireSameTeam" }; }
    BitFieldValue<bool, unsigned __int32> bBuffDrawFloatingHUD() { return { this, "APrimalBuff.bBuffDrawFloatingHUD" }; }
    BitFieldValue<bool, unsigned __int32> bAddResetsBuffTime() { return { this, "APrimalBuff.bAddResetsBuffTime" }; }
    BitFieldValue<bool, unsigned __int32> bAoEBuffAllowIfAlreadyBuffed() { return { this, "APrimalBuff.bAoEBuffAllowIfAlreadyBuffed" }; }
    BitFieldValue<bool, unsigned __int32> bNetResetBuffStart() { return { this, "APrimalBuff.bNetResetBuffStart" }; }
    BitFieldValue<bool, unsigned __int32> bImmobilizeTarget() { return { this, "APrimalBuff.bImmobilizeTarget" }; }
    BitFieldValue<bool, unsigned __int32> bForcePlayerProne() { return { this, "APrimalBuff.bForcePlayerProne" }; }
    BitFieldValue<bool, unsigned __int32> bHideBuffFromHUD() { return { this, "APrimalBuff.bHideBuffFromHUD" }; }
    BitFieldValue<bool, unsigned __int32> bHideTimerFromHUD() { return { this, "APrimalBuff.bHideTimerFromHUD" }; }
    BitFieldValue<bool, unsigned __int32> bBPAddMultiUseEntries() { return { this, "APrimalBuff.bBPAddMultiUseEntries" }; }
    BitFieldValue<bool, unsigned __int32> bIsBuffPersistent() { return { this, "APrimalBuff.bIsBuffPersistent" }; }
    BitFieldValue<bool, unsigned __int32> bBPUseBumpedByPawn() { return { this, "APrimalBuff.bBPUseBumpedByPawn" }; }
    BitFieldValue<bool, unsigned __int32> bBPUseBumpedPawn() { return { this, "APrimalBuff.bBPUseBumpedPawn" }; }
    BitFieldValue<bool, unsigned __int32> bAllowBuffWhenInstigatorDead() { return { this, "APrimalBuff.bAllowBuffWhenInstigatorDead" }; }
    BitFieldValue<bool, unsigned __int32> bNotifyDamage() { return { this, "APrimalBuff.bNotifyDamage" }; }
    BitFieldValue<bool, unsigned __int32> bAllowBuffStasis() { return { this, "APrimalBuff.bAllowBuffStasis" }; }
    BitFieldValue<bool, unsigned __int32> bApplyStatModifierToPlayers() { return { this, "APrimalBuff.bApplyStatModifierToPlayers" }; }
    BitFieldValue<bool, unsigned __int32> bApplyStatModifierToDinos() { return { this, "APrimalBuff.bApplyStatModifierToDinos" }; }
    BitFieldValue<bool, unsigned __int32> bPreventOnWildDino() { return { this, "APrimalBuff.bPreventOnWildDino" }; }
    BitFieldValue<bool, unsigned __int32> bPreventOnDino() { return { this, "APrimalBuff.bPreventOnDino" }; }
    BitFieldValue<bool, unsigned __int32> bPreventOnPlayer() { return { this, "APrimalBuff.bPreventOnPlayer" }; }
    BitFieldValue<bool, unsigned __int32> bPreventOnBigDino() { return { this, "APrimalBuff.bPreventOnBigDino" }; }
    BitFieldValue<bool, unsigned __int32> bPreventOnBossDino() { return { this, "APrimalBuff.bPreventOnBossDino" }; }
    BitFieldValue<bool, unsigned __int32> bPreventOnRobotDino() { return { this, "APrimalBuff.bPreventOnRobotDino" }; }
    BitFieldValue<bool, unsigned __int32> bIsDisease() { return { this, "APrimalBuff.bIsDisease" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPPreventAddingOtherBuff() { return { this, "APrimalBuff.bUseBPPreventAddingOtherBuff" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPPreventRunning() { return { this, "APrimalBuff.bUseBPPreventRunning" }; }
    BitFieldValue<bool, unsigned __int32> bAddReactivates() { return { this, "APrimalBuff.bAddReactivates" }; }
    BitFieldValue<bool, unsigned __int32> bAoEApplyDamageAllTargetables() { return { this, "APrimalBuff.bAoEApplyDamageAllTargetables" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPAdjustCharacterMovementImpulse() { return { this, "APrimalBuff.bUseBPAdjustCharacterMovementImpulse" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPAdjustImpulseFromDamage() { return { this, "APrimalBuff.bUseBPAdjustImpulseFromDamage" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPGetHUDElements() { return { this, "APrimalBuff.bUseBPGetHUDElements" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPActivated() { return { this, "APrimalBuff.bUseBPActivated" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPHandleOnStartFire() { return { this, "APrimalBuff.bUseBPHandleOnStartFire" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPPreventFlight() { return { this, "APrimalBuff.bUseBPPreventFlight" }; }
    BitFieldValue<bool, unsigned __int32> bRequireController() { return { this, "APrimalBuff.bRequireController" }; }
    BitFieldValue<bool, unsigned __int32> bDontPlayInstigatorActiveSoundOnDino() { return { this, "APrimalBuff.bDontPlayInstigatorActiveSoundOnDino" }; }
    BitFieldValue<bool, unsigned __int32> bAddExtendBuffTime() { return { this, "APrimalBuff.bAddExtendBuffTime" }; }
    BitFieldValue<bool, unsigned __int32> bUseTickingDeactivation() { return { this, "APrimalBuff.bUseTickingDeactivation" }; }
    BitFieldValue<bool, unsigned __int32> bCheckPreventInput() { return { this, "APrimalBuff.bCheckPreventInput" }; }
    BitFieldValue<bool, unsigned __int32> bBPDrawBuffStatusHUD() { return { this, "APrimalBuff.bBPDrawBuffStatusHUD" }; }
    BitFieldValue<bool, unsigned __int32> bEnableStaticPathing() { return { this, "APrimalBuff.bEnableStaticPathing" }; }
    BitFieldValue<bool, unsigned __int32> bHUDFormatTimerAsTimecode() { return { this, "APrimalBuff.bHUDFormatTimerAsTimecode" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPPreventThrowingItem() { return { this, "APrimalBuff.bUseBPPreventThrowingItem" }; }
    BitFieldValue<bool, unsigned __int32> bPreventInputDoesOffset() { return { this, "APrimalBuff.bPreventInputDoesOffset" }; }
    BitFieldValue<bool, unsigned __int32> bNotifyExperienceGained() { return { this, "APrimalBuff.bNotifyExperienceGained" }; }
    BitFieldValue<bool, unsigned __int32> bOnlyTickWhenVisible() { return { this, "APrimalBuff.bOnlyTickWhenVisible" }; }
    BitFieldValue<bool, unsigned __int32> bBPAdjustStatusValueModification() { return { this, "APrimalBuff.bBPAdjustStatusValueModification" }; }
    BitFieldValue<bool, unsigned __int32> bWasDestroyed() { return { this, "APrimalBuff.bWasDestroyed" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPNotifyOtherBuffActivated() { return { this, "APrimalBuff.bUseBPNotifyOtherBuffActivated" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPNotifyOtherBuffDeactivated() { return { this, "APrimalBuff.bUseBPNotifyOtherBuffDeactivated" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPPreventFirstPerson() { return { this, "APrimalBuff.bUseBPPreventFirstPerson" }; }
    BitFieldValue<bool, unsigned __int32> bForceAddUnderwaterCharacterStatusValues() { return { this, "APrimalBuff.bForceAddUnderwaterCharacterStatusValues" }; }
    BitFieldValue<bool, unsigned __int32> bPreventInstigatorAttack() { return { this, "APrimalBuff.bPreventInstigatorAttack" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOnInstigatorMovementModeChangedNotify() { return { this, "APrimalBuff.bUseBPOnInstigatorMovementModeChangedNotify" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPPreventInstigatorMovementMode() { return { this, "APrimalBuff.bUseBPPreventInstigatorMovementMode" }; }
    BitFieldValue<bool, unsigned __int32> bUseBPOverrideTalkerCharacter() { return { this, "APrimalBuff.bUseBPOverrideTalkerCharacter" }; }
 
    // Functions
 
    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "APrimalBuff.StaticClass"); }
    void Deactivate() { NativeCall<void>(this, "APrimalBuff.Deactivate"); }
    void NetDeactivate_Implementation() { NativeCall<void>(this, "APrimalBuff.NetDeactivate_Implementation"); }
    void BeginPlay() { NativeCall<void>(this, "APrimalBuff.BeginPlay"); }
    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "APrimalBuff.GetLifetimeReplicatedProps", OutLifetimeProps); }
    void AddDamageStatusValueModifier(APrimalCharacter* addToCharacter, EPrimalCharacterStatusValue::Type ValueType, bool bSpeedToAddInSeconds, bool bContinueOnUnchangedValue, bool bResetExistingModifierDescriptionIndex, bool bSetValue, bool bSetAdditionalValue, float LimitExistingModifierDescriptionToMaxAmount, float damageMultiplierAmountToAdd, float speedToAdd, int StatusValueModifierDescriptionIndex, bool bUsePercentualDamage, bool bMakeUntameable, float percentualDamage, TSubclassOf<UDamageType> ScaleValueByCharacterDamageType) { NativeCall<void, APrimalCharacter*, EPrimalCharacterStatusValue::Type, bool, bool, bool, bool, bool, float, float, float, int, bool, bool, float, TSubclassOf<UDamageType>>(this, "APrimalBuff.AddDamageStatusValueModifier", addToCharacter, ValueType, bSpeedToAddInSeconds, bContinueOnUnchangedValue, bResetExistingModifierDescriptionIndex, bSetValue, bSetAdditionalValue, LimitExistingModifierDescriptionToMaxAmount, damageMultiplierAmountToAdd, speedToAdd, StatusValueModifierDescriptionIndex, bUsePercentualDamage, bMakeUntameable, percentualDamage, ScaleValueByCharacterDamageType); }
    void SetupForInstigator() { NativeCall<void>(this, "APrimalBuff.SetupForInstigator"); }
    void Tick(float DeltaSeconds) { NativeCall<void, float>(this, "APrimalBuff.Tick", DeltaSeconds); }
    void ProcessStaticPathing(bool triggerRunning) { NativeCall<void, bool>(this, "APrimalBuff.ProcessStaticPathing", triggerRunning); }
    FVector* UpdateStaticPathingDestination(FVector* result, FVector locOverride, float randomOffsetMultiplier, bool useRandomNegativeXDir, bool orientRandOffsetByRotation, FRotator randOffsetByRotation, float GroundCheckSpreadOverride) { return NativeCall<FVector*, FVector*, FVector, float, bool, bool, FRotator, float>(this, "APrimalBuff.UpdateStaticPathingDestination", result, locOverride, randomOffsetMultiplier, useRandomNegativeXDir, orientRandOffsetByRotation, randOffsetByRotation, GroundCheckSpreadOverride); }
    void EnableTickFunction() { NativeCall<void>(this, "APrimalBuff.EnableTickFunction"); }
    bool AOEBuffCanAffect(APrimalCharacter* forChar) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalBuff.AOEBuffCanAffect", forChar); }
    void InstigatorJumped() { NativeCall<void>(this, "APrimalBuff.InstigatorJumped"); }
    void Destroyed() { NativeCall<void>(this, "APrimalBuff.Destroyed"); }
    void NetResetBuffStart_Implementation() { NativeCall<void>(this, "APrimalBuff.NetResetBuffStart_Implementation"); }
    bool ResetBuffStart() { return NativeCall<bool>(this, "APrimalBuff.ResetBuffStart"); }
    APrimalBuff* AddBuff(APrimalCharacter* ForCharacter, AActor* DamageCauser) { return NativeCall<APrimalBuff*, APrimalCharacter*, AActor*>(this, "APrimalBuff.AddBuff", ForCharacter, DamageCauser); }
    void GetHUDElements(APlayerController* ForPC, TArray<FHUDElement>* OutHUDElements) { NativeCall<void, APlayerController*, TArray<FHUDElement>*>(this, "APrimalBuff.GetHUDElements", ForPC, OutHUDElements); }
    static APrimalBuff* StaticAddBuff(TSubclassOf<APrimalBuff> BuffClass, APrimalCharacter* ForCharacter, UPrimalItem* AssociatedItem, AActor* DamageCauser, bool bForceOnClient) { return NativeCall<APrimalBuff*, TSubclassOf<APrimalBuff>, APrimalCharacter*, UPrimalItem*, AActor*, bool>(nullptr, "APrimalBuff.StaticAddBuff", BuffClass, ForCharacter, AssociatedItem, DamageCauser, bForceOnClient); }
    bool ExcludePostProcessBlendableMaterial(UMaterialInterface* BlendableMaterialInterface) { return NativeCall<bool, UMaterialInterface*>(this, "APrimalBuff.ExcludePostProcessBlendableMaterial", BlendableMaterialInterface); }
    bool PreventActorTargeting_Implementation(AActor* ByActor) { return NativeCall<bool, AActor*>(this, "APrimalBuff.PreventActorTargeting_Implementation", ByActor); }
    bool PreventRunning() { return NativeCall<bool>(this, "APrimalBuff.PreventRunning"); }
    bool ExcludeAoEActor(AActor* ActorToConsider) { return NativeCall<bool, AActor*>(this, "APrimalBuff.ExcludeAoEActor", ActorToConsider); }
    bool HideBuffFromHUD_Implementation() { return NativeCall<bool>(this, "APrimalBuff.HideBuffFromHUD_Implementation"); }
    void Stasis() { NativeCall<void>(this, "APrimalBuff.Stasis"); }
    void Unstasis() { NativeCall<void>(this, "APrimalBuff.Unstasis"); }
    bool ExtendBuffTime(float AmountOfAdditionalTime) { return NativeCall<bool, float>(this, "APrimalBuff.ExtendBuffTime", AmountOfAdditionalTime); }
    int GetBuffType_Implementation() { return NativeCall<int>(this, "APrimalBuff.GetBuffType_Implementation"); }
    bool ReduceBuffTime(float AmountOfTimeToReduce) { return NativeCall<bool, float>(this, "APrimalBuff.ReduceBuffTime", AmountOfTimeToReduce); }
    bool IsNetRelevantFor(APlayerController* RealViewer, AActor* Viewer, FVector* SrcLocation) { return NativeCall<bool, APlayerController*, AActor*, FVector*>(this, "APrimalBuff.IsNetRelevantFor", RealViewer, Viewer, SrcLocation); }
    bool IsValidUnStasisCaster() { return NativeCall<bool>(this, "APrimalBuff.IsValidUnStasisCaster"); }
    FString* GetDebugInfoString(FString* result) { return NativeCall<FString*, FString*>(this, "APrimalBuff.GetDebugInfoString", result); }
    void BPGetHUDElements(APlayerController* ForPC, TArray<FHUDElement>* OutElements) { NativeCall<void, APlayerController*, TArray<FHUDElement>*>(this, "APrimalBuff.BPGetHUDElements", ForPC, OutElements); }
    void BPOverrideCameraViewTarget(FName CurrentCameraMode, FVector DesiredCameraLocation, FRotator DesiredCameraRotation, float DesiredFOV, bool* bOverrideCameraLocation, FVector* CameraLocation, bool* bOverrideCameraRotation, FRotator* CameraRotation, bool* bOverrideCameraFOV, float* CameraFOV) { NativeCall<void, FName, FVector, FRotator, float, bool*, FVector*, bool*, FRotator*, bool*, float*>(this, "APrimalBuff.BPOverrideCameraViewTarget", CurrentCameraMode, DesiredCameraLocation, DesiredCameraRotation, DesiredFOV, bOverrideCameraLocation, CameraLocation, bOverrideCameraRotation, CameraRotation, bOverrideCameraFOV, CameraFOV); }
    static void StaticRegisterNativesAPrimalBuff() { NativeCall<void>(nullptr, "APrimalBuff.StaticRegisterNativesAPrimalBuff"); }
    void BPDrawBuffStatusHUD(AShooterHUD* HUD, float XPos, float YPos, float ScaleMult) { NativeCall<void, AShooterHUD*, float, float, float>(this, "APrimalBuff.BPDrawBuffStatusHUD", HUD, XPos, YPos, ScaleMult); }
    void BPOnInstigatorCapsuleComponentHit(AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector* NormalImpulse, FHitResult* Hit) { NativeCall<void, AActor*, UPrimitiveComponent*, FVector*, FHitResult*>(this, "APrimalBuff.BPOnInstigatorCapsuleComponentHit", OtherActor, OtherComp, NormalImpulse, Hit); }
    float BuffAdjustDamage(float Damage, FHitResult* HitInfo, AController* EventInstigator, AActor* DamageCauser, TSubclassOf<UDamageType> TheDamgeType) { return NativeCall<float, float, FHitResult*, AController*, AActor*, TSubclassOf<UDamageType>>(this, "APrimalBuff.BuffAdjustDamage", Damage, HitInfo, EventInstigator, DamageCauser, TheDamgeType); }
    void BuffPostAdjustDamage(float Damage, FHitResult* HitInfo, AController* EventInstigator, AActor* DamageCauser, TSubclassOf<UDamageType> TheDamgeType) { NativeCall<void, float, FHitResult*, AController*, AActor*, TSubclassOf<UDamageType>>(this, "APrimalBuff.BuffPostAdjustDamage", Damage, HitInfo, EventInstigator, DamageCauser, TheDamgeType); }
    void DrawBuffFloatingHUD(int BuffIndex, AShooterHUD* HUD, float CenterX, float CenterY, float DrawScale) { NativeCall<void, int, AShooterHUD*, float, float, float>(this, "APrimalBuff.DrawBuffFloatingHUD", BuffIndex, HUD, CenterX, CenterY, DrawScale); }
    FStatusValueModifierDescription* GetBuffDescription(FStatusValueModifierDescription* result) { return NativeCall<FStatusValueModifierDescription*, FStatusValueModifierDescription*>(this, "APrimalBuff.GetBuffDescription", result); }
    int GetBuffType() { return NativeCall<int>(this, "APrimalBuff.GetBuffType"); }
    void NotifyDamage(float DamageAmount, TSubclassOf<UDamageType> DamageClass, AController* EventInstigator, AActor* TheDamageCauser) { NativeCall<void, float, TSubclassOf<UDamageType>, AController*, AActor*>(this, "APrimalBuff.NotifyDamage", DamageAmount, DamageClass, EventInstigator, TheDamageCauser); }
    bool PreventActorTargeting(AActor* ByActor) { return NativeCall<bool, AActor*>(this, "APrimalBuff.PreventActorTargeting", ByActor); }
    void SetBuffCauser(AActor* CausedBy) { NativeCall<void, AActor*>(this, "APrimalBuff.SetBuffCauser", CausedBy); }
};
 
struct APrimalBuff_Grappled : APrimalBuff
{
    // Functions
 
    void BreakAllTethers() { NativeCall<void>(this, "APrimalBuff_Grappled.BreakAllTethers"); }
};
 
struct FHarvestResourceEntry
{
    int OverrideQuantityMax;
    int OverrideQuantityMin;
    float OverrideQuantityRandomPower;
    float EntryWeight;
    float EffectivenessQuantityMultiplier;
    float EffectivenessQualityMultiplier;
    TSubclassOf<UPrimalItem> ResourceItem;
    float QualityMin;
    float QualityMax;
    float XPGainMax;
    float XPGainMin;
    TArray<TSubclassOf<UDamageType>> DamageTypeEntryValuesOverrides;
    TArray<float> DamageTypeEntryWeightOverrides;
    TArray<float> DamageTypeEntryMinQuantityOverrides;
    TArray<float> DamageTypeEntryMaxQuantityOverrides;
    __int8 bScaleWithDinoBabyAge : 1;
};
 
struct UMeshComponent : UPrimitiveComponent
{
    FieldArray<char, 8> MaterialsField() { return { this, "UMeshComponent.Materials" }; }
 
    // Functions
 
    void BeginDestroy() { NativeCall<void>(this, "UMeshComponent.BeginDestroy"); }
    void SetMaterial(int ElementIndex, UMaterialInterface* Material) { NativeCall<void, int, UMaterialInterface*>(this, "UMeshComponent.SetMaterial", ElementIndex, Material); }
    void GetUsedMaterials(TArray<UMaterialInterface*>* OutMaterials) { NativeCall<void, TArray<UMaterialInterface*>*>(this, "UMeshComponent.GetUsedMaterials", OutMaterials); }
    void PrestreamTextures(float Seconds, bool bPrioritizeCharacterTextures, int CinematicTextureGroups) { NativeCall<void, float, bool, int>(this, "UMeshComponent.PrestreamTextures", Seconds, bPrioritizeCharacterTextures, CinematicTextureGroups); }
    void SetTextureForceResidentFlag(bool bForceMiplevelsToBeResident) { NativeCall<void, bool>(this, "UMeshComponent.SetTextureForceResidentFlag", bForceMiplevelsToBeResident); }
    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "UMeshComponent.GetPrivateStaticClass", Package); }
    TArray<UMaterialInterface*, FDefaultAllocator> Materials;
    TArray<UMaterialInterface*, FDefaultAllocator> DefaultMaterialsOverride;
    TSubclassOf<AActor> DamageFXActorToSpawn;
};
 
struct USkinnedMeshComponent : UMeshComponent
{
    TArray<FTransform>& SpaceBasesField() { return *GetNativePointerField<TArray<FTransform>*>(this, "USkinnedMeshComponent.SpaceBases"); }
    TArray<int>& MasterBoneMapField() { return *GetNativePointerField<TArray<int>*>(this, "USkinnedMeshComponent.MasterBoneMap"); }
    //TArray<FActiveVertexAnim>& ActiveVertexAnimsField() { return *GetNativePointerField<TArray<FActiveVertexAnim>*>(this, "USkinnedMeshComponent.ActiveVertexAnims"); }
    //UPhysicsAsset* PhysicsAssetOverrideField() { return GetNativePointerField<UPhysicsAsset*>(this, "USkinnedMeshComponent.PhysicsAssetOverride"); }
    int& ForcedLodModelField() { return *GetNativePointerField<int*>(this, "USkinnedMeshComponent.ForcedLodModel"); }
    int& MinLodModelField() { return *GetNativePointerField<int*>(this, "USkinnedMeshComponent.MinLodModel"); }
    int& PredictedLODLevelField() { return *GetNativePointerField<int*>(this, "USkinnedMeshComponent.PredictedLODLevel"); }
    int& OldPredictedLODLevelField() { return *GetNativePointerField<int*>(this, "USkinnedMeshComponent.OldPredictedLODLevel"); }
    float& MaxDistanceFactorField() { return *GetNativePointerField<float*>(this, "USkinnedMeshComponent.MaxDistanceFactor"); }
    float& ShadowedRecentlyRenderedBoundsScaleMultiplierField() { return *GetNativePointerField<float*>(this, "USkinnedMeshComponent.ShadowedRecentlyRenderedBoundsScaleMultiplier"); }
    //TArray<FSkelMeshComponentLODInfo>& LODInfoField() { return *GetNativePointerField<TArray<FSkelMeshComponentLODInfo>*>(this, "USkinnedMeshComponent.LODInfo"); }
    float& StreamingDistanceMultiplierField() { return *GetNativePointerField<float*>(this, "USkinnedMeshComponent.StreamingDistanceMultiplier"); }
    FColor& WireframeColorField() { return *GetNativePointerField<FColor*>(this, "USkinnedMeshComponent.WireframeColor"); }
    float& ForceTickPoseWithinRangeSquaredField() { return *GetNativePointerField<float*>(this, "USkinnedMeshComponent.ForceTickPoseWithinRangeSquared"); }
    TArray<unsigned char>& BoneVisibilityStatesField() { return *GetNativePointerField<TArray<unsigned char>*>(this, "USkinnedMeshComponent.BoneVisibilityStates"); }
    //TEnumAsByte<enum EMeshComponentUpdateFlag::Type>& MeshComponentUpdateFlagField() { return *GetNativePointerField<TEnumAsByte<enum EMeshComponentUpdateFlag::Type>*>(this, "USkinnedMeshComponent.MeshComponentUpdateFlag"); }
    float& ProgressiveDrawingFractionField() { return *GetNativePointerField<float*>(this, "USkinnedMeshComponent.ProgressiveDrawingFraction"); }
    char& CustomSortAlternateIndexModeField() { return *GetNativePointerField<char*>(this, "USkinnedMeshComponent.CustomSortAlternateIndexMode"); }
    FBoxSphereBounds& CachedLocalBoundsField() { return *GetNativePointerField<FBoxSphereBounds*>(this, "USkinnedMeshComponent.CachedLocalBounds"); }
    bool& bCachedLocalBoundsUpToDateField() { return *GetNativePointerField<bool*>(this, "USkinnedMeshComponent.bCachedLocalBoundsUpToDate"); }
    bool& bEnableUpdateRateOptimizationsField() { return *GetNativePointerField<bool*>(this, "USkinnedMeshComponent.bEnableUpdateRateOptimizations"); }
    bool& bDisplayDebugUpdateRateOptimizationsField() { return *GetNativePointerField<bool*>(this, "USkinnedMeshComponent.bDisplayDebugUpdateRateOptimizations"); }
    float& SkippedTickDeltaTimeField() { return *GetNativePointerField<float*>(this, "USkinnedMeshComponent.SkippedTickDeltaTime"); }
    bool& bPoseTickedField() { return *GetNativePointerField<bool*>(this, "USkinnedMeshComponent.bPoseTicked"); }
    //FAnimUpdateRateParameters& AnimUpdateRateParamsField() { return *GetNativePointerField<FAnimUpdateRateParameters*>(this, "USkinnedMeshComponent.AnimUpdateRateParams"); }
 
    // Functions
 
    FBoxSphereBounds* CalcBounds(FBoxSphereBounds* result, FTransform* LocalToWorld) { return NativeCall<FBoxSphereBounds*, FBoxSphereBounds*, FTransform*>(this, "USkinnedMeshComponent.CalcBounds", result, LocalToWorld); }
    void Serialize(FArchive* Ar) { NativeCall<void, FArchive*>(this, "USkinnedMeshComponent.Serialize", Ar); }
    //unsigned __int64 GetResourceSize(EResourceSizeMode::Type Mode) { return NativeCall<unsigned __int64, EResourceSizeMode::Type>(this, "USkinnedMeshComponent.GetResourceSize", Mode); }
    void OnRegister() { NativeCall<void>(this, "USkinnedMeshComponent.OnRegister"); }
    void OnUnregister() { NativeCall<void>(this, "USkinnedMeshComponent.OnUnregister"); }
    void CreateRenderState_Concurrent() { NativeCall<void>(this, "USkinnedMeshComponent.CreateRenderState_Concurrent"); }
    void DestroyRenderState_Concurrent() { NativeCall<void>(this, "USkinnedMeshComponent.DestroyRenderState_Concurrent"); }
    FString* GetDetailedInfoInternal(FString* result) { return NativeCall<FString*, FString*>(this, "USkinnedMeshComponent.GetDetailedInfoInternal", result); }
    void SendRenderDynamicData_Concurrent() { NativeCall<void>(this, "USkinnedMeshComponent.SendRenderDynamicData_Concurrent"); }
    void InitLODInfos() { NativeCall<void>(this, "USkinnedMeshComponent.InitLODInfos"); }
    bool ShouldTickPose() { return NativeCall<bool>(this, "USkinnedMeshComponent.ShouldTickPose"); }
    bool ShouldUpdateTransform(bool bLODHasChanged) { return NativeCall<bool, bool>(this, "USkinnedMeshComponent.ShouldUpdateTransform", bLODHasChanged); }
    void TickUpdateRate() { NativeCall<void>(this, "USkinnedMeshComponent.TickUpdateRate"); }
    int GetNumMaterials() { return NativeCall<int>(this, "USkinnedMeshComponent.GetNumMaterials"); }
    //void GetStreamingTextureInfo(TArray<FStreamingTexturePrimitiveInfo>* OutStreamingTextures) { NativeCall<void, TArray<FStreamingTexturePrimitiveInfo>*>(this, "USkinnedMeshComponent.GetStreamingTextureInfo", OutStreamingTextures); }
    bool ShouldUpdateBoneVisibility() { return NativeCall<bool>(this, "USkinnedMeshComponent.ShouldUpdateBoneVisibility"); }
    void RebuildVisibilityArray() { NativeCall<void>(this, "USkinnedMeshComponent.RebuildVisibilityArray"); }
    //UPhysicsAsset* GetPhysicsAsset() { return NativeCall<UPhysicsAsset*>(this, "USkinnedMeshComponent.GetPhysicsAsset"); }
    FBoxSphereBounds* CalcMeshBound(FBoxSphereBounds* result, FVector* RootOffset, bool UsePhysicsAsset, FTransform* LocalToWorld) { return NativeCall<FBoxSphereBounds*, FBoxSphereBounds*, FVector*, bool, FTransform*>(this, "USkinnedMeshComponent.CalcMeshBound", result, RootOffset, UsePhysicsAsset, LocalToWorld); }
    //FMatrix* GetBoneMatrix(FMatrix* result, int BoneIdx) { return NativeCall<FMatrix*, FMatrix*, int>(this, "USkinnedMeshComponent.GetBoneMatrix", result, BoneIdx); }
    FTransform* GetBoneTransform(FTransform* result, int BoneIdx) { return NativeCall<FTransform*, FTransform*, int>(this, "USkinnedMeshComponent.GetBoneTransform", result, BoneIdx); }
    int GetBoneIndex(FName BoneName) { return NativeCall<int, FName>(this, "USkinnedMeshComponent.GetBoneIndex", BoneName); }
    FName* GetBoneName(FName* result, int BoneIndex) { return NativeCall<FName*, FName*, int>(this, "USkinnedMeshComponent.GetBoneName", result, BoneIndex); }
    //void SetSkeletalMesh(USkeletalMesh* InSkelMesh) { NativeCall<void, USkeletalMesh*>(this, "USkinnedMeshComponent.SetSkeletalMesh", InSkelMesh); }
    //FSkeletalMeshResource* GetSkeletalMeshResource() { return NativeCall<FSkeletalMeshResource*>(this, "USkinnedMeshComponent.GetSkeletalMeshResource"); }
    bool AllocateTransformData() { return NativeCall<bool>(this, "USkinnedMeshComponent.AllocateTransformData"); }
    void DeallocateTransformData() { NativeCall<void>(this, "USkinnedMeshComponent.DeallocateTransformData"); }
    //void SetPhysicsAsset(UPhysicsAsset* InPhysicsAsset, bool bForceReInit) { NativeCall<void, UPhysicsAsset*, bool>(this, "USkinnedMeshComponent.SetPhysicsAsset", InPhysicsAsset, bForceReInit); }
    void SetMasterPoseComponent(USkinnedMeshComponent* NewMasterBoneComponent) { NativeCall<void, USkinnedMeshComponent*>(this, "USkinnedMeshComponent.SetMasterPoseComponent", NewMasterBoneComponent); }
    void InvalidateCachedBounds() { NativeCall<void>(this, "USkinnedMeshComponent.InvalidateCachedBounds"); }
    void RefreshSlaveComponents() { NativeCall<void>(this, "USkinnedMeshComponent.RefreshSlaveComponents"); }
    //UMorphTarget* FindMorphTarget(FName MorphTargetName) { return NativeCall<UMorphTarget*, FName>(this, "USkinnedMeshComponent.FindMorphTarget", MorphTargetName); }
    void UpdateMasterBoneMap() { NativeCall<void>(this, "USkinnedMeshComponent.UpdateMasterBoneMap"); }
    TArray<FName>* GetAllSocketNames(TArray<FName>* result) { return NativeCall<TArray<FName>*, TArray<FName>*>(this, "USkinnedMeshComponent.GetAllSocketNames", result); }
    FTransform* GetSocketTransform(FTransform* result, FName InSocketName, ERelativeTransformSpace TransformSpace) { return NativeCall<FTransform*, FTransform*, FName, ERelativeTransformSpace>(this, "USkinnedMeshComponent.GetSocketTransform", result, InSocketName, TransformSpace); }
    bool DoesSocketExist(FName InSocketName) { return NativeCall<bool, FName>(this, "USkinnedMeshComponent.DoesSocketExist", InSocketName); }
    FQuat* GetBoneQuaternion(FQuat* result, FName BoneName, int Space) { return NativeCall<FQuat*, FQuat*, FName, int>(this, "USkinnedMeshComponent.GetBoneQuaternion", result, BoneName, Space); }
    FVector* GetBoneLocation(FVector* result, FName BoneName, int Space) { return NativeCall<FVector*, FVector*, FName, int>(this, "USkinnedMeshComponent.GetBoneLocation", result, BoneName, Space); }
    bool HasAnySockets() { return NativeCall<bool>(this, "USkinnedMeshComponent.HasAnySockets"); }
    //void QuerySupportedSockets(TArray<FComponentSocketDescription>* OutSockets) { NativeCall<void, TArray<FComponentSocketDescription>*>(this, "USkinnedMeshComponent.QuerySupportedSockets", OutSockets); }
    void UpdateOverlaps(TArray<FOverlapInfo>* PendingOverlaps, bool bDoNotifies, TArray<FOverlapInfo>* OverlapsAtEndLocation) { NativeCall<void, TArray<FOverlapInfo>*, bool, TArray<FOverlapInfo>*>(this, "USkinnedMeshComponent.UpdateOverlaps", PendingOverlaps, bDoNotifies, OverlapsAtEndLocation); }
    void TransformToBoneSpace(FName BoneName, FVector InPosition, FRotator InRotation, FVector* OutPosition, FRotator* OutRotation) { NativeCall<void, FName, FVector, FRotator, FVector*, FRotator*>(this, "USkinnedMeshComponent.TransformToBoneSpace", BoneName, InPosition, InRotation, OutPosition, OutRotation); }
    void TransformFromBoneSpace(FName BoneName, FVector InPosition, FRotator InRotation, FVector* OutPosition, FRotator* OutRotation) { NativeCall<void, FName, FVector, FRotator, FVector*, FRotator*>(this, "USkinnedMeshComponent.TransformFromBoneSpace", BoneName, InPosition, InRotation, OutPosition, OutRotation); }
    FName* FindClosestBone(FName* result, FVector TestLocation, FVector* BoneLocation, float IgnoreScale) { return NativeCall<FName*, FName*, FVector, FVector*, float>(this, "USkinnedMeshComponent.FindClosestBone", result, TestLocation, BoneLocation, IgnoreScale); }
    void GetUsedMaterials(TArray<UMaterialInterface*>* OutMaterials) { NativeCall<void, TArray<UMaterialInterface*>*>(this, "USkinnedMeshComponent.GetUsedMaterials", OutMaterials); }
    FVector* GetSkinnedVertexPosition(FVector* result, int VertexIndex) { return NativeCall<FVector*, FVector*, int>(this, "USkinnedMeshComponent.GetSkinnedVertexPosition", result, VertexIndex); }
    void ComputeSkinnedPositions(TArray<FVector>* OutPositions) { NativeCall<void, TArray<FVector>*>(this, "USkinnedMeshComponent.ComputeSkinnedPositions", OutPositions); }
    FColor* GetVertexColor(FColor* result, int VertexIndex) { return NativeCall<FColor*, FColor*, int>(this, "USkinnedMeshComponent.GetVertexColor", result, VertexIndex); }
    //void HideBone(int BoneIndex, EPhysBodyOp PhysBodyOption) { NativeCall<void, int, EPhysBodyOp>(this, "USkinnedMeshComponent.HideBone", BoneIndex, PhysBodyOption); }
    void UnHideBone(int BoneIndex) { NativeCall<void, int>(this, "USkinnedMeshComponent.UnHideBone", BoneIndex); }
    bool IsBoneHidden(int BoneIndex) { return NativeCall<bool, int>(this, "USkinnedMeshComponent.IsBoneHidden", BoneIndex); }
    bool IsBoneHiddenByName(FName BoneName) { return NativeCall<bool, FName>(this, "USkinnedMeshComponent.IsBoneHiddenByName", BoneName); }
    //void HideBoneByName(FName BoneName, EPhysBodyOp PhysBodyOption) { NativeCall<void, FName, EPhysBodyOp>(this, "USkinnedMeshComponent.HideBoneByName", BoneName, PhysBodyOption); }
    void UnHideBoneByName(FName BoneName) { NativeCall<void, FName>(this, "USkinnedMeshComponent.UnHideBoneByName", BoneName); }
    bool UpdateLODStatus() { return NativeCall<bool>(this, "USkinnedMeshComponent.UpdateLODStatus"); }
    //static TArray<FActiveVertexAnim>* UpdateActiveVertexAnims(TArray<FActiveVertexAnim>* result, USkeletalMesh* InSkeletalMesh, TMap<FName, float, FDefaultSetAllocator, TDefaultMapKeyFuncs<FName, float, 0> >* MorphCurveAnims, TArray<FActiveVertexAnim>* ActiveAnims) { return NativeCall<TArray<FActiveVertexAnim>*, TArray<FActiveVertexAnim>*, USkeletalMesh*, TMap<FName, float, FDefaultSetAllocator, TDefaultMapKeyFuncs<FName, float, 0> >*, TArray<FActiveVertexAnim>*>(nullptr, "USkinnedMeshComponent.UpdateActiveVertexAnims", result, InSkeletalMesh, MorphCurveAnims, ActiveAnims); }
    void AnimUpdateRateTick() { NativeCall<void>(this, "USkinnedMeshComponent.AnimUpdateRateTick"); }
    void AnimUpdateRateSetParams(const bool* bRecentlyRendered, const float* MaxDistanceFactor, const bool* bPlayingRootMotion) { NativeCall<void, const bool*, const float*, const bool*>(this, "USkinnedMeshComponent.AnimUpdateRateSetParams", bRecentlyRendered, MaxDistanceFactor, bPlayingRootMotion); }
};
 
struct USkeletalMeshComponent : USkinnedMeshComponent
{
    //TEnumAsByte<enum EAnimationMode::Type>& AnimationModeField() { return *GetNativePointerField<TEnumAsByte<enum EAnimationMode::Type>*>(this, "USkeletalMeshComponent.AnimationMode"); }
    FVector& InterpolatedRootLocationField() { return *GetNativePointerField<FVector*>(this, "USkeletalMeshComponent.InterpolatedRootLocation"); }
    FRotator& InterpolatedRootRotationField() { return *GetNativePointerField<FRotator*>(this, "USkeletalMeshComponent.InterpolatedRootRotation"); }
    FVector& CurrentSkeletonUpDirField() { return *GetNativePointerField<FVector*>(this, "USkeletalMeshComponent.CurrentSkeletonUpDir"); }
    TArray<float>& OriginalBonesOffsetsField() { return *GetNativePointerField<TArray<float>*>(this, "USkeletalMeshComponent.OriginalBonesOffsets"); }
    //TArray<FIKLegInfo>& IkLegsField() { return *GetNativePointerField<TArray<FIKLegInfo>*>(this, "USkeletalMeshComponent.IkLegs"); }
    //TArray<FIKGroundPlaneOverrideInfo>& IkGroundPlaneOverridesField() { return *GetNativePointerField<TArray<FIKGroundPlaneOverrideInfo>*>(this, "USkeletalMeshComponent.IkGroundPlaneOverrides"); }
    //TArray<FIKRootAdjustmentInfo>& IkRootAdjustmentPointsField() { return *GetNativePointerField<TArray<FIKRootAdjustmentInfo>*>(this, "USkeletalMeshComponent.IkRootAdjustmentPoints"); }
    float& IkRootAdjustmentHeightCSField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.IkRootAdjustmentHeightCS"); }
    float& IkRootOffsetInterpSpeedField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.IkRootOffsetInterpSpeed"); }
    float& IkRootOffsetInterpSpeedUpField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.IkRootOffsetInterpSpeedUp"); }
    float& IkRootWorldOffsetInterpSpeedField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.IkRootWorldOffsetInterpSpeed"); }
    float& IkRootWorldOffsetInterpSpeedUpField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.IkRootWorldOffsetInterpSpeedUp"); }
    float& IkInterpSpeedField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.IkInterpSpeed"); }
    float& IkInterpSpeedUpField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.IkInterpSpeedUp"); }
    float& IkFabrikInterpSpeedField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.IkFabrikInterpSpeed"); }
    float& IkFeetAlignmentInterpSpeedField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.IkFeetAlignmentInterpSpeed"); }
    float& IkGroundPlaneInterpSpeedField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.IkGroundPlaneInterpSpeed"); }
    float& MinHitNormalZForFeetAlignmentField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.MinHitNormalZForFeetAlignment"); }
    float& FeetAlignmentLimitField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.FeetAlignmentLimit"); }
    float& LegLimitRatioFromCylinderHeightField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.LegLimitRatioFromCylinderHeight"); }
    FRotator& IkRootRotationOffsetField() { return *GetNativePointerField<FRotator*>(this, "USkeletalMeshComponent.IkRootRotationOffset"); }
    FVector& IkRootLocationOffsetField() { return *GetNativePointerField<FVector*>(this, "USkeletalMeshComponent.IkRootLocationOffset"); }
    float& DinoIKDelayedTraceFreezeDurationMultiplierField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.DinoIKDelayedTraceFreezeDurationMultiplier"); }
    float& DinoIKSlopeMatchingRootHeightOffsetField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.DinoIKSlopeMatchingRootHeightOffset"); }
    float& DinoIKAnimationLegZOffsetingMultiplierField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.DinoIKAnimationLegZOffsetingMultiplier"); }
    FVector& TwoLegVirtualHitLocationWSField() { return *GetNativePointerField<FVector*>(this, "USkeletalMeshComponent.TwoLegVirtualHitLocationWS"); }
    FVector& TwoLegVirtualHitLocationWSTargetField() { return *GetNativePointerField<FVector*>(this, "USkeletalMeshComponent.TwoLegVirtualHitLocationWSTarget"); }
    FVector& TwoLegVirtualHitLocationCSField() { return *GetNativePointerField<FVector*>(this, "USkeletalMeshComponent.TwoLegVirtualHitLocationCS"); }
    float& DistanceFromGroundToStartIKField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.DistanceFromGroundToStartIK"); }
    float& DistanceFromGroundToStartIKBiasField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.DistanceFromGroundToStartIKBias"); }
    int& MaxIterationsField() { return *GetNativePointerField<int*>(this, "USkeletalMeshComponent.MaxIterations"); }
    float& MatchSlopeRotationSpeedField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.MatchSlopeRotationSpeed"); }
    float& RootPitchRotationLimitField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.RootPitchRotationLimit"); }
    float& RootRollRotationLimitField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.RootRollRotationLimit"); }
    float& ForceUpdateValuesTimeLimitField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.ForceUpdateValuesTimeLimit"); }
    float& RootOffsetField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.RootOffset"); }
    FRotator& RootRotationOffsetField() { return *GetNativePointerField<FRotator*>(this, "USkeletalMeshComponent.RootRotationOffset"); }
    long double& LastIkUpdateTimeField() { return *GetNativePointerField<long double*>(this, "USkeletalMeshComponent.LastIkUpdateTime"); }
    int& LastIKCalculationFrameField() { return *GetNativePointerField<int*>(this, "USkeletalMeshComponent.LastIKCalculationFrame"); }
    long double& ForceIkUpdateTimeField() { return *GetNativePointerField<long double*>(this, "USkeletalMeshComponent.ForceIkUpdateTime"); }
    long double& IKFirstFrozenUpdatedTimeField() { return *GetNativePointerField<long double*>(this, "USkeletalMeshComponent.IKFirstFrozenUpdatedTime"); }
    long double& LastIKFrozenStartTimeField() { return *GetNativePointerField<long double*>(this, "USkeletalMeshComponent.LastIKFrozenStartTime"); }
    float& LastRootZField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.LastRootZ"); }
    FQuat& CurrentGroundSlopeField() { return *GetNativePointerField<FQuat*>(this, "USkeletalMeshComponent.CurrentGroundSlope"); }
    bool& bMovedLastFrameField() { return *GetNativePointerField<bool*>(this, "USkeletalMeshComponent.bMovedLastFrame"); }
    bool& bNeedsUpdateToCachedLegInfosField() { return *GetNativePointerField<bool*>(this, "USkeletalMeshComponent.bNeedsUpdateToCachedLegInfos"); }
    bool& bUsingFrozenIKField() { return *GetNativePointerField<bool*>(this, "USkeletalMeshComponent.bUsingFrozenIK"); }
    long double& TimeToStopUpdatingLegCachesField() { return *GetNativePointerField<long double*>(this, "USkeletalMeshComponent.TimeToStopUpdatingLegCaches"); }
    //TArray<FIKLegInfo>& LastCachedIKLegInfosField() { return *GetNativePointerField<TArray<FIKLegInfo>*>(this, "USkeletalMeshComponent.LastCachedIKLegInfos"); }
    FVector& CachedTwoLegVirtualHitLocationWSField() { return *GetNativePointerField<FVector*>(this, "USkeletalMeshComponent.CachedTwoLegVirtualHitLocationWS"); }
    FVector& CachedTwoLegVirtualHitLocationCSField() { return *GetNativePointerField<FVector*>(this, "USkeletalMeshComponent.CachedTwoLegVirtualHitLocationCS"); }
    FVector& LastIKPositionField() { return *GetNativePointerField<FVector*>(this, "USkeletalMeshComponent.LastIKPosition"); }
    float& BoneModifiersLegLengthPercentageField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.BoneModifiersLegLengthPercentage"); }
    //TArray<FBoneModifier>& CurrentBoneModifiersField() { return *GetNativePointerField<TArray<FBoneModifier>*>(this, "USkeletalMeshComponent.CurrentBoneModifiers"); }
    //UAnimBlueprintGeneratedClass* AnimBlueprintGeneratedClassField() { return GetNativePointerField<UAnimBlueprintGeneratedClass*>(this, "USkeletalMeshComponent.AnimBlueprintGeneratedClass"); }
    //FSingleAnimationPlayData& AnimationDataField() { return *GetNativePointerField<FSingleAnimationPlayData*>(this, "USkeletalMeshComponent.AnimationData"); }
    TArray<FTransform>& LocalAtomsField() { return *GetNativePointerField<TArray<FTransform>*>(this, "USkeletalMeshComponent.LocalAtoms"); }
    long double& LastMeshGameplayRelevantTimeField() { return *GetNativePointerField<long double*>(this, "USkeletalMeshComponent.LastMeshGameplayRelevantTime"); }
    TArray<FTransform>& CachedLocalAtomsField() { return *GetNativePointerField<TArray<FTransform>*>(this, "USkeletalMeshComponent.CachedLocalAtoms"); }
    TArray<FTransform>& CachedSpaceBasesField() { return *GetNativePointerField<TArray<FTransform>*>(this, "USkeletalMeshComponent.CachedSpaceBases"); }
    float& GlobalAnimRateScaleField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.GlobalAnimRateScale"); }
    //TEnumAsByte<enum EKinematicBonesUpdateToPhysics::Type>& KinematicBonesUpdateTypeField() { return *GetNativePointerField<TEnumAsByte<enum EKinematicBonesUpdateToPhysics::Type>*>(this, "USkeletalMeshComponent.KinematicBonesUpdateType"); }
    float& ComponentMassScaleField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.ComponentMassScale"); }
    float& MinLinearDampingField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.MinLinearDamping"); }
    float& MinAngularDampingField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.MinAngularDamping"); }
    float& TeleportDistanceThresholdField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.TeleportDistanceThreshold"); }
    float& TeleportRotationThresholdField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.TeleportRotationThreshold"); }
    float& ClothBlendWeightField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.ClothBlendWeight"); }
    FVector& RootBoneTranslationField() { return *GetNativePointerField<FVector*>(this, "USkeletalMeshComponent.RootBoneTranslation"); }
    int& NumNonZeroLODsField() { return *GetNativePointerField<int*>(this, "USkeletalMeshComponent.NumNonZeroLODs"); }
    TEnumAsByte<enum ECollisionEnabled::Type>& PreSleepingKinematicsCollisionTypeField() { return *GetNativePointerField<TEnumAsByte<enum ECollisionEnabled::Type>*>(this, "USkeletalMeshComponent.PreSleepingKinematicsCollisionType"); }
    FVector& LineCheckBoundsScaleField() { return *GetNativePointerField<FVector*>(this, "USkeletalMeshComponent.LineCheckBoundsScale"); }
    TArray<unsigned short>& RequiredBonesField() { return *GetNativePointerField<TArray<unsigned short>*>(this, "USkeletalMeshComponent.RequiredBones"); }
    int& RootBodyIndexField() { return *GetNativePointerField<int*>(this, "USkeletalMeshComponent.RootBodyIndex"); }
    TArray<FBodyInstance*>& BodiesField() { return *GetNativePointerField<TArray<FBodyInstance*>*>(this, "USkeletalMeshComponent.Bodies"); }
    //TArray<FConstraintInstance*>& ConstraintsField() { return *GetNativePointerField<TArray<FConstraintInstance*>*>(this, "USkeletalMeshComponent.Constraints"); }
    //physx::PxAggregate* AggregateField() { return GetNativePointerField<physx::PxAggregate*>(this, "USkeletalMeshComponent.Aggregate"); }
    TMap<FName, float, FDefaultSetAllocator, TDefaultMapKeyFuncs<FName, float, 0> >& MorphTargetCurvesField() { return *GetNativePointerField<TMap<FName, float, FDefaultSetAllocator, TDefaultMapKeyFuncs<FName, float, 0> >*>(this, "USkeletalMeshComponent.MorphTargetCurves"); }
    //FAnimationEvaluationContext& AnimEvaluationContextField() { return *GetNativePointerField<FAnimationEvaluationContext*>(this, "USkeletalMeshComponent.AnimEvaluationContext"); }
    //TRefCountPtr<FGraphEvent>& ParallelAnimationEvaluationTaskField() { return *GetNativePointerField<TRefCountPtr<FGraphEvent>*>(this, "USkeletalMeshComponent.ParallelAnimationEvaluationTask"); }
    //TRefCountPtr<FGraphEvent>& ParallelBlendPhysicsCompletionTaskField() { return *GetNativePointerField<TRefCountPtr<FGraphEvent>*>(this, "USkeletalMeshComponent.ParallelBlendPhysicsCompletionTask"); }
    float& ForcedBlueprintBlendCurrentWeightField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.ForcedBlueprintBlendCurrentWeight"); }
    float& ForcedBlueprintBlendDurationField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.ForcedBlueprintBlendDuration"); }
    TArray<FTransform>& ForcedBlueprintBlendCachedBonesField() { return *GetNativePointerField<TArray<FTransform>*>(this, "USkeletalMeshComponent.ForcedBlueprintBlendCachedBones"); }
    UAnimSequence* SequenceToPlay_DEPRECATEDField() { return GetNativePointerField<UAnimSequence*>(this, "USkeletalMeshComponent.SequenceToPlay_DEPRECATED"); }
    float& DefaultPosition_DEPRECATEDField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.DefaultPosition_DEPRECATED"); }
    float& DefaultPlayRate_DEPRECATEDField() { return *GetNativePointerField<float*>(this, "USkeletalMeshComponent.DefaultPlayRate_DEPRECATED"); }
    int& TickingModulusField() { return *GetNativePointerField<int*>(this, "USkeletalMeshComponent.TickingModulus"); }
    int& LowQualityTickingModulusField() { return *GetNativePointerField<int*>(this, "USkeletalMeshComponent.LowQualityTickingModulus"); }
    int& LastKinematicWorldUpdateFrameField() { return *GetNativePointerField<int*>(this, "USkeletalMeshComponent.LastKinematicWorldUpdateFrame"); }
    long double& LastTickTimeField() { return *GetNativePointerField<long double*>(this, "USkeletalMeshComponent.LastTickTime"); }
    long double& PreventSoundCuesTimeField() { return *GetNativePointerField<long double*>(this, "USkeletalMeshComponent.PreventSoundCuesTime"); }
    long double& DisableParallelAnimationsTimeField() { return *GetNativePointerField<long double*>(this, "USkeletalMeshComponent.DisableParallelAnimationsTime"); }
    bool& IgnoreStaggeredUpdatesThisTickField() { return *GetNativePointerField<bool*>(this, "USkeletalMeshComponent.IgnoreStaggeredUpdatesThisTick"); }
    int& StaggeredUIDField() { return *GetNativePointerField<int*>(this, "USkeletalMeshComponent.StaggeredUID"); }
 
    // Functions
 
    void Serialize(FArchive* Ar) { NativeCall<void, FArchive*>(this, "USkeletalMeshComponent.Serialize", Ar); }
    void OnRegister() { NativeCall<void>(this, "USkeletalMeshComponent.OnRegister"); }
    void OnUnregister() { NativeCall<void>(this, "USkeletalMeshComponent.OnUnregister"); }
    //void BPSetBoneModifiers(TArray<FBoneModifierNamed>* NamedBoneModifiers) { NativeCall<void, TArray<FBoneModifierNamed>*>(this, "USkeletalMeshComponent.BPSetBoneModifiers", NamedBoneModifiers); }
    void RemoveBasedPawns(USceneComponent* BasedOnComponent) { NativeCall<void, USceneComponent*>(this, "USkeletalMeshComponent.RemoveBasedPawns", BasedOnComponent); }
    bool IsPlayingAnimationMontagesOnSlotName(FName SlotName) { return NativeCall<bool, FName>(this, "USkeletalMeshComponent.IsPlayingAnimationMontagesOnSlotName", SlotName); }
    void InitAnim(bool bForceReinit) { NativeCall<void, bool>(this, "USkeletalMeshComponent.InitAnim", bForceReinit); }
    void InitializeAnimScriptInstance(bool bForceReinit) { NativeCall<void, bool>(this, "USkeletalMeshComponent.InitializeAnimScriptInstance", bForceReinit); }
    void CreateRenderState_Concurrent() { NativeCall<void>(this, "USkeletalMeshComponent.CreateRenderState_Concurrent"); }
    void InitializeComponent() { NativeCall<void>(this, "USkeletalMeshComponent.InitializeComponent"); }
    void TickAnimation(float DeltaTime) { NativeCall<void, float>(this, "USkeletalMeshComponent.TickAnimation", DeltaTime); }
    bool UpdateLODStatus() { return NativeCall<bool>(this, "USkeletalMeshComponent.UpdateLODStatus"); }
    bool ShouldUpdateTransform(bool bLODHasChanged) { return NativeCall<bool, bool>(this, "USkeletalMeshComponent.ShouldUpdateTransform", bLODHasChanged); }
    bool ShouldTickPose() { return NativeCall<bool>(this, "USkeletalMeshComponent.ShouldTickPose"); }
    void TickPose(float DeltaTime) { NativeCall<void, float>(this, "USkeletalMeshComponent.TickPose", DeltaTime); }
    //void FillSpaceBases(USkeletalMesh* InSkeletalMesh, TArray<FTransform>* SourceAtoms, TArray<FTransform>* DestSpaceBases) { NativeCall<void, USkeletalMesh*, TArray<FTransform>*, TArray<FTransform>*>(this, "USkeletalMeshComponent.FillSpaceBases", InSkeletalMesh, SourceAtoms, DestSpaceBases); }
    void RecalcRequiredBones(int LODIndex) { NativeCall<void, int>(this, "USkeletalMeshComponent.RecalcRequiredBones", LODIndex); }
    //void EvaluateAnimation(USkeletalMesh* InSkeletalMesh, UAnimInstance* InAnimInstance, TArray<FTransform>* OutLocalAtoms, TArray<FActiveVertexAnim>* OutVertexAnims, FVector* OutRootBoneTranslation) { NativeCall<void, USkeletalMesh*, UAnimInstance*, TArray<FTransform>*, TArray<FActiveVertexAnim>*, FVector*>(this, "USkeletalMeshComponent.EvaluateAnimation", InSkeletalMesh, InAnimInstance, OutLocalAtoms, OutVertexAnims, OutRootBoneTranslation); }
    void UpdateSlaveComponent() { NativeCall<void>(this, "USkeletalMeshComponent.UpdateSlaveComponent"); }
    //void PerformAnimationEvaluation(USkeletalMesh* InSkeletalMesh, UAnimInstance* InAnimInstance, TArray<FTransform>* OutSpaceBases, TArray<FTransform>* OutLocalAtoms, TArray<FActiveVertexAnim>* OutVertexAnims, FVector* OutRootBoneTranslation) { NativeCall<void, USkeletalMesh*, UAnimInstance*, TArray<FTransform>*, TArray<FTransform>*, TArray<FActiveVertexAnim>*, FVector*>(this, "USkeletalMeshComponent.PerformAnimationEvaluation", InSkeletalMesh, InAnimInstance, OutSpaceBases, OutLocalAtoms, OutVertexAnims, OutRootBoneTranslation); }
    //void PostAnimEvaluation(FAnimationEvaluationContext* EvaluationContext) { NativeCall<void, FAnimationEvaluationContext*>(this, "USkeletalMeshComponent.PostAnimEvaluation", EvaluationContext); }
    void UpdateBounds() { NativeCall<void>(this, "USkeletalMeshComponent.UpdateBounds"); }
    FBoxSphereBounds* CalcBounds(FBoxSphereBounds* result, FTransform* LocalToWorld) { return NativeCall<FBoxSphereBounds*, FBoxSphereBounds*, FTransform*>(this, "USkeletalMeshComponent.CalcBounds", result, LocalToWorld); }
    FTransform* CalcNewComponentToWorld(FTransform* result, FTransform* NewRelativeTransform, USceneComponent* Parent) { return NativeCall<FTransform*, FTransform*, FTransform*, USceneComponent*>(this, "USkeletalMeshComponent.CalcNewComponentToWorld", result, NewRelativeTransform, Parent); }
    FVector* GetMeshScaleMultiplier(FVector* result) { return NativeCall<FVector*, FVector*>(this, "USkeletalMeshComponent.GetMeshScaleMultiplier", result); }
    //void SetSkeletalMesh(USkeletalMesh* InSkelMesh) { NativeCall<void, USkeletalMesh*>(this, "USkeletalMeshComponent.SetSkeletalMesh", InSkelMesh); }
    bool AllocateTransformData() { return NativeCall<bool>(this, "USkeletalMeshComponent.AllocateTransformData"); }
    void DeallocateTransformData() { NativeCall<void>(this, "USkeletalMeshComponent.DeallocateTransformData"); }
    void SetAnimInstanceClass(UClass* NewClass) { NativeCall<void, UClass*>(this, "USkeletalMeshComponent.SetAnimInstanceClass", NewClass); }
    //FMatrix* GetTransformMatrix(FMatrix* result) { return NativeCall<FMatrix*, FMatrix*>(this, "USkeletalMeshComponent.GetTransformMatrix", result); }
    //void SkelMeshCompOnParticleSystemFinished(UParticleSystemComponent* PSC) { NativeCall<void, UParticleSystemComponent*>(this, "USkeletalMeshComponent.SkelMeshCompOnParticleSystemFinished", PSC); }
    //void HideBone(int BoneIndex, EPhysBodyOp PhysBodyOption) { NativeCall<void, int, EPhysBodyOp>(this, "USkeletalMeshComponent.HideBone", BoneIndex, PhysBodyOption); }
    void UnHideBone(int BoneIndex) { NativeCall<void, int>(this, "USkeletalMeshComponent.UnHideBone", BoneIndex); }
    bool IsAnySimulatingPhysics() { return NativeCall<bool>(this, "USkeletalMeshComponent.IsAnySimulatingPhysics"); }
    float GetOverrideWalkableZ(AActor* ForActor) { return NativeCall<float, AActor*>(this, "USkeletalMeshComponent.GetOverrideWalkableZ", ForActor); }
    //void DebugDrawBones(UCanvas* Canvas, bool bSimpleBones) { NativeCall<void, UCanvas*, bool>(this, "USkeletalMeshComponent.DebugDrawBones", Canvas, bSimpleBones); }
    //void RenderAxisGizmo(FTransform* Transform, UCanvas* Canvas) { NativeCall<void, FTransform*, UCanvas*>(this, "USkeletalMeshComponent.RenderAxisGizmo", Transform, Canvas); }
    void SetMorphTarget(FName MorphTargetName, float Value) { NativeCall<void, FName, float>(this, "USkeletalMeshComponent.SetMorphTarget", MorphTargetName, Value); }
    //unsigned __int64 GetResourceSize(EResourceSizeMode::Type Mode) { return NativeCall<unsigned __int64, EResourceSizeMode::Type>(this, "USkeletalMeshComponent.GetResourceSize", Mode); }
    //void SetAnimationMode(EAnimationMode::Type InAnimationMode) { NativeCall<void, EAnimationMode::Type>(this, "USkeletalMeshComponent.SetAnimationMode", InAnimationMode); }
    //void PlayAnimation(UAnimationAsset* NewAnimToPlay, bool bLooping) { NativeCall<void, UAnimationAsset*, bool>(this, "USkeletalMeshComponent.PlayAnimation", NewAnimToPlay, bLooping); }
    //void SetAnimation(UAnimationAsset* NewAnimToPlay) { NativeCall<void, UAnimationAsset*>(this, "USkeletalMeshComponent.SetAnimation", NewAnimToPlay); }
    bool IsPlayingMontage(UAnimMontage* Montage, float TimeFromEndToConsiderFinished) { return NativeCall<bool, UAnimMontage*, float>(this, "USkeletalMeshComponent.IsPlayingMontage", Montage, TimeFromEndToConsiderFinished); }
    void SetPosition(float InPos, bool bFireNotifies) { NativeCall<void, float, bool>(this, "USkeletalMeshComponent.SetPosition", InPos, bFireNotifies); }
    FTransform* ConvertLocalRootMotionToWorld(FTransform* result, FTransform* InTransform) { return NativeCall<FTransform*, FTransform*, FTransform*>(this, "USkeletalMeshComponent.ConvertLocalRootMotionToWorld", result, InTransform); }
    float CalculateMass(FName BoneName) { return NativeCall<float, FName>(this, "USkeletalMeshComponent.CalculateMass", BoneName); }
    bool IsPlayingRootMotion() { return NativeCall<bool>(this, "USkeletalMeshComponent.IsPlayingRootMotion"); }
    void SetCollisionObjectType(ECollisionChannel Channel) { NativeCall<void, ECollisionChannel>(this, "USkeletalMeshComponent.SetCollisionObjectType", Channel); }
    void SetCollisionEnabled(ECollisionEnabled::Type NewType) { NativeCall<void, ECollisionEnabled::Type>(this, "USkeletalMeshComponent.SetCollisionEnabled", NewType); }
    void UpdateComponentToWorld(bool bSkipPhysicsMove) { NativeCall<void, bool>(this, "USkeletalMeshComponent.UpdateComponentToWorld", bSkipPhysicsMove); }
    void RecreatePhysicsState(bool bRestoreBoneTransforms) { NativeCall<void, bool>(this, "USkeletalMeshComponent.RecreatePhysicsState", bRestoreBoneTransforms); }
    void SkippedTickPose() { NativeCall<void>(this, "USkeletalMeshComponent.SkippedTickPose"); }
    bool HandleExistingParallelEvaluationTask(bool bBlockOnTask, bool bPerformPostAnimEvaluation) { return NativeCall<bool, bool, bool>(this, "USkeletalMeshComponent.HandleExistingParallelEvaluationTask", bBlockOnTask, bPerformPostAnimEvaluation); }
    void FlushMorphTargets() { NativeCall<void>(this, "USkeletalMeshComponent.FlushMorphTargets"); }
    void CreateBodySetup() { NativeCall<void>(this, "USkeletalMeshComponent.CreateBodySetup"); }
    bool ContainsPhysicsTriMeshData(bool InUseAllTriData) { return NativeCall<bool, bool>(this, "USkeletalMeshComponent.ContainsPhysicsTriMeshData", InUseAllTriData); }
    bool CanEditSimulatePhysics() { return NativeCall<bool>(this, "USkeletalMeshComponent.CanEditSimulatePhysics"); }
    void SetSimulatePhysics(bool bSimulate) { NativeCall<void, bool>(this, "USkeletalMeshComponent.SetSimulatePhysics", bSimulate); }
    void OnComponentCollisionSettingsChanged() { NativeCall<void>(this, "USkeletalMeshComponent.OnComponentCollisionSettingsChanged"); }
    void AddRadialImpulse(FVector Origin, float Radius, float Strength, ERadialImpulseFalloff Falloff, bool bVelChange) { NativeCall<void, FVector, float, float, ERadialImpulseFalloff, bool>(this, "USkeletalMeshComponent.AddRadialImpulse", Origin, Radius, Strength, Falloff, bVelChange); }
    void AddRadialForce(FVector Origin, float Radius, float Strength, ERadialImpulseFalloff Falloff) { NativeCall<void, FVector, float, float, ERadialImpulseFalloff>(this, "USkeletalMeshComponent.AddRadialForce", Origin, Radius, Strength, Falloff); }
    void WakeAllRigidBodies() { NativeCall<void>(this, "USkeletalMeshComponent.WakeAllRigidBodies"); }
    void PutAllRigidBodiesToSleep() { NativeCall<void>(this, "USkeletalMeshComponent.PutAllRigidBodiesToSleep"); }
    bool IsAnyRigidBodyAwake() { return NativeCall<bool>(this, "USkeletalMeshComponent.IsAnyRigidBodyAwake"); }
    void SetAllPhysicsLinearVelocity(FVector NewVel, bool bAddToCurrent) { NativeCall<void, FVector, bool>(this, "USkeletalMeshComponent.SetAllPhysicsLinearVelocity", NewVel, bAddToCurrent); }
    void SetAllPhysicsAngularVelocity(FVector* NewAngVel, bool bAddToCurrent) { NativeCall<void, FVector*, bool>(this, "USkeletalMeshComponent.SetAllPhysicsAngularVelocity", NewAngVel, bAddToCurrent); }
    void SetAllPhysicsPosition(FVector NewPos) { NativeCall<void, FVector>(this, "USkeletalMeshComponent.SetAllPhysicsPosition", NewPos); }
    void SetAllPhysicsRotation(FRotator NewRot) { NativeCall<void, FRotator>(this, "USkeletalMeshComponent.SetAllPhysicsRotation", NewRot); }
    void ApplyDeltaToAllPhysicsTransforms(FVector* DeltaLocation, FQuat* DeltaRotation) { NativeCall<void, FVector*, FQuat*>(this, "USkeletalMeshComponent.ApplyDeltaToAllPhysicsTransforms", DeltaLocation, DeltaRotation); }
    void SetPhysMaterialOverride(UPhysicalMaterial* NewPhysMaterial) { NativeCall<void, UPhysicalMaterial*>(this, "USkeletalMeshComponent.SetPhysMaterialOverride", NewPhysMaterial); }
    //void InitArticulated(FPhysScene* PhysScene, bool bForceOnDedicatedServer) { NativeCall<void, FPhysScene*, bool>(this, "USkeletalMeshComponent.InitArticulated", PhysScene, bForceOnDedicatedServer); }
    void TermArticulated() { NativeCall<void>(this, "USkeletalMeshComponent.TermArticulated"); }
    void TermBodiesBelow(FName ParentBoneName) { NativeCall<void, FName>(this, "USkeletalMeshComponent.TermBodiesBelow", ParentBoneName); }
    void SetAllBodiesSimulatePhysics(bool bNewSimulate) { NativeCall<void, bool>(this, "USkeletalMeshComponent.SetAllBodiesSimulatePhysics", bNewSimulate); }
    void SetAllBodiesSleepThreshold(float SleepThresh) { NativeCall<void, float>(this, "USkeletalMeshComponent.SetAllBodiesSleepThreshold", SleepThresh); }
    void SetAllBodiesBelowSimulatePhysics(FName* InBoneName, bool bNewSimulate) { NativeCall<void, FName*, bool>(this, "USkeletalMeshComponent.SetAllBodiesBelowSimulatePhysics", InBoneName, bNewSimulate); }
    void ResetAllBodiesSimulatePhysics() { NativeCall<void>(this, "USkeletalMeshComponent.ResetAllBodiesSimulatePhysics"); }
    void SetPhysicsBlendWeight(float PhysicsBlendWeight) { NativeCall<void, float>(this, "USkeletalMeshComponent.SetPhysicsBlendWeight", PhysicsBlendWeight); }
    void SetAllBodiesPhysicsBlendWeight(float PhysicsBlendWeight, bool bSkipCustomPhysicsType) { NativeCall<void, float, bool>(this, "USkeletalMeshComponent.SetAllBodiesPhysicsBlendWeight", PhysicsBlendWeight, bSkipCustomPhysicsType); }
    void SetAllBodiesBelowPhysicsBlendWeight(FName* InBoneName, float PhysicsBlendWeight, bool bSkipCustomPhysicsType) { NativeCall<void, FName*, float, bool>(this, "USkeletalMeshComponent.SetAllBodiesBelowPhysicsBlendWeight", InBoneName, PhysicsBlendWeight, bSkipCustomPhysicsType); }
    void AccumulateAllBodiesBelowPhysicsBlendWeight(FName* InBoneName, float PhysicsBlendWeight, bool bSkipCustomPhysicsType) { NativeCall<void, FName*, float, bool>(this, "USkeletalMeshComponent.AccumulateAllBodiesBelowPhysicsBlendWeight", InBoneName, PhysicsBlendWeight, bSkipCustomPhysicsType); }
    void OnUpdateTransform(bool bSkipPhysicsMove) { NativeCall<void, bool>(this, "USkeletalMeshComponent.OnUpdateTransform", bSkipPhysicsMove); }
    void CreatePhysicsState() { NativeCall<void>(this, "USkeletalMeshComponent.CreatePhysicsState"); }
    void DestroyPhysicsState() { NativeCall<void>(this, "USkeletalMeshComponent.DestroyPhysicsState"); }
    FBodyInstance* GetBodyInstance(FName BoneName, bool __formal) { return NativeCall<FBodyInstance*, FName, bool>(this, "USkeletalMeshComponent.GetBodyInstance", BoneName, __formal); }
    void GetWeldedBodies(TArray<FBodyInstance*>* OutWeldedBodies, TArray<FName>* OutLabels) { NativeCall<void, TArray<FBodyInstance*>*, TArray<FName>*>(this, "USkeletalMeshComponent.GetWeldedBodies", OutWeldedBodies, OutLabels); }
    //void SetPhysicsAsset(UPhysicsAsset* InPhysicsAsset, bool bForceReInit) { NativeCall<void, UPhysicsAsset*, bool>(this, "USkeletalMeshComponent.SetPhysicsAsset", InPhysicsAsset, bForceReInit); }
    void UpdateHasValidBodies() { NativeCall<void>(this, "USkeletalMeshComponent.UpdateHasValidBodies"); }
    void UpdatePhysicsToRBChannels() { NativeCall<void>(this, "USkeletalMeshComponent.UpdatePhysicsToRBChannels"); }
    FVector* GetSkinnedVertexPosition(FVector* result, int VertexIndex) { return NativeCall<FVector*, FVector*, int>(this, "USkeletalMeshComponent.GetSkinnedVertexPosition", result, VertexIndex); }
    bool LineTraceComponent(FHitResult* OutHit, FVector Start, FVector End, FCollisionQueryParams* Params) { return NativeCall<bool, FHitResult*, FVector, FVector, FCollisionQueryParams*>(this, "USkeletalMeshComponent.LineTraceComponent", OutHit, Start, End, Params); }
    //bool SweepComponent(FHitResult* OutHit, FVector Start, FVector End, FCollisionShape* CollisionShape, bool bTraceComplex) { return NativeCall<bool, FHitResult*, FVector, FVector, FCollisionShape*, bool>(this, "USkeletalMeshComponent.SweepComponent", OutHit, Start, End, CollisionShape, bTraceComplex); }
    bool ComponentOverlapComponentImpl(UPrimitiveComponent* PrimComp, FVector Pos, FQuat* Quat, FCollisionQueryParams* Params) { return NativeCall<bool, UPrimitiveComponent*, FVector, FQuat*, FCollisionQueryParams*>(this, "USkeletalMeshComponent.ComponentOverlapComponentImpl", PrimComp, Pos, Quat, Params); }
    //bool OverlapComponent(FVector* Pos, FQuat* Rot, FCollisionShape* CollisionShape) { return NativeCall<bool, FVector*, FQuat*, FCollisionShape*>(this, "USkeletalMeshComponent.OverlapComponent", Pos, Rot, CollisionShape); }
    //bool ComponentOverlapMultiImpl(TArray<FOverlapResult>* OutOverlaps, UWorld* World, FVector* Pos, FQuat* Quat, ECollisionChannel TestChannel, FComponentQueryParams* Params, FCollisionObjectQueryParams* ObjectQueryParams) { return NativeCall<bool, TArray<FOverlapResult>*, UWorld*, FVector*, FQuat*, ECollisionChannel, FComponentQueryParams*, FCollisionObjectQueryParams*>(this, "USkeletalMeshComponent.ComponentOverlapMultiImpl", OutOverlaps, World, Pos, Quat, TestChannel, Params, ObjectQueryParams); }
    float GetMass() { return NativeCall<float>(this, "USkeletalMeshComponent.GetMass"); }
    void CompleteParallelAnimationEvaluation(bool bDoPostAnimEvaluation) { NativeCall<void, bool>(this, "USkeletalMeshComponent.CompleteParallelAnimationEvaluation", bDoPostAnimEvaluation); }
    void ParallelAnimationEvaluation() { NativeCall<void>(this, "USkeletalMeshComponent.ParallelAnimationEvaluation"); }
    void UpdateKinematicBonesToPhysics(bool bTeleport, bool bNeedsSkinning, bool bForceUpdate, bool bAbsoluteForceUpdate, bool bOnlyDisableKinematicCollisions) { NativeCall<void, bool, bool, bool, bool, bool>(this, "USkeletalMeshComponent.UpdateKinematicBonesToPhysics", bTeleport, bNeedsSkinning, bForceUpdate, bAbsoluteForceUpdate, bOnlyDisableKinematicCollisions); }
    void UpdateRBJointMotors() { NativeCall<void>(this, "USkeletalMeshComponent.UpdateRBJointMotors"); }
};
 
struct UStaticMeshComponent : UMeshComponent
{
    UStaticMesh* StaticMeshField() { return GetNativePointerField<UStaticMesh*>(this, "UStaticMeshComponent.StaticMesh"); }
    bool& bOverrideWireframeColorField() { return *GetNativePointerField<bool*>(this, "UStaticMeshComponent.bOverrideWireframeColor"); }
    FColor& WireframeColorOverrideField() { return *GetNativePointerField<FColor*>(this, "UStaticMeshComponent.WireframeColorOverride"); }
    int& LandscapeInfoMaskField() { return *GetNativePointerField<int*>(this, "UStaticMeshComponent.LandscapeInfoMask"); }
    int& OverriddenLightMapResField() { return *GetNativePointerField<int*>(this, "UStaticMeshComponent.OverriddenLightMapRes"); }
    float& StreamingDistanceMultiplierField() { return *GetNativePointerField<float*>(this, "UStaticMeshComponent.StreamingDistanceMultiplier"); }
    int& SubDivisionStepSizeField() { return *GetNativePointerField<int*>(this, "UStaticMeshComponent.SubDivisionStepSize"); }
    TArray<FGuid>& IrrelevantLightsField() { return *GetNativePointerField<TArray<FGuid>*>(this, "UStaticMeshComponent.IrrelevantLights"); }
    //TArray<FStaticMeshComponentLODInfo>& LODDataField() { return *GetNativePointerField<TArray<FStaticMeshComponentLODInfo>*>(this, "UStaticMeshComponent.LODData"); }
    //FLightmassPrimitiveSettings& LightmassSettingsField() { return *GetNativePointerField<FLightmassPrimitiveSettings*>(this, "UStaticMeshComponent.LightmassSettings"); }
 
    // Functions
 
    static UClass* StaticClass() { return NativeCall<UClass*>(nullptr, "UStaticMeshComponent.StaticClass"); }
    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "UStaticMeshComponent.GetPrivateStaticClass", Package); }
    bool GetShadowIndirectOnly() { return NativeCall<bool>(this, "UStaticMeshComponent.GetShadowIndirectOnly"); }
    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "UStaticMeshComponent.GetLifetimeReplicatedProps", OutLifetimeProps); }
    bool HasAnySockets() { return NativeCall<bool>(this, "UStaticMeshComponent.HasAnySockets"); }
    //void QuerySupportedSockets(TArray<FComponentSocketDescription>* OutSockets) { NativeCall<void, TArray<FComponentSocketDescription>*>(this, "UStaticMeshComponent.QuerySupportedSockets", OutSockets); }
    TArray<FName>* GetAllSocketNames(TArray<FName>* result) { return NativeCall<TArray<FName>*, TArray<FName>*>(this, "UStaticMeshComponent.GetAllSocketNames", result); }
    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", InThis, Collector); }
    void Serialize(FArchive* Ar) { NativeCall<void, FArchive*>(this, "UStaticMeshComponent.Serialize", Ar); }
    bool AreNativePropertiesIdenticalTo(UObject* Other) { return NativeCall<bool, UObject*>(this, "UStaticMeshComponent.AreNativePropertiesIdenticalTo", Other); }
    FBoxSphereBounds* CalcBounds(FBoxSphereBounds* result, FTransform* LocalToWorld) { return NativeCall<FBoxSphereBounds*, FBoxSphereBounds*, FTransform*>(this, "UStaticMeshComponent.CalcBounds", result, LocalToWorld); }
    void OnRegister() { NativeCall<void>(this, "UStaticMeshComponent.OnRegister"); }
    void OnUnregister() { NativeCall<void>(this, "UStaticMeshComponent.OnUnregister"); }
    //void GetStreamingTextureInfo(TArray<FStreamingTexturePrimitiveInfo>* OutStreamingTextures) { NativeCall<void, TArray<FStreamingTexturePrimitiveInfo>*>(this, "UStaticMeshComponent.GetStreamingTextureInfo", OutStreamingTextures); }
    bool CanEditSimulatePhysics() { return NativeCall<bool>(this, "UStaticMeshComponent.CanEditSimulatePhysics"); }
    bool DoesSocketExist(FName InSocketName) { return NativeCall<bool, FName>(this, "UStaticMeshComponent.DoesSocketExist", InSocketName); }
    UStaticMeshSocket* GetSocketByName(FName InSocketName) { return NativeCall<UStaticMeshSocket*, FName>(this, "UStaticMeshComponent.GetSocketByName", InSocketName); }
    FTransform* GetSocketTransform(FTransform* result, FName InSocketName, ERelativeTransformSpace TransformSpace) { return NativeCall<FTransform*, FTransform*, FName, ERelativeTransformSpace>(this, "UStaticMeshComponent.GetSocketTransform", result, InSocketName, TransformSpace); }
    void BeginDestroy() { NativeCall<void>(this, "UStaticMeshComponent.BeginDestroy"); }
    void ExportCustomProperties(FOutputDevice* Out, unsigned int Indent) { NativeCall<void, FOutputDevice*, unsigned int>(this, "UStaticMeshComponent.ExportCustomProperties", Out, Indent); }
    //void ImportCustomProperties(const wchar_t* SourceText, FFeedbackContext* Warn) { NativeCall<void, const wchar_t*, FFeedbackContext*>(this, "UStaticMeshComponent.ImportCustomProperties", SourceText, Warn); }
    void PostLoad() { NativeCall<void>(this, "UStaticMeshComponent.PostLoad"); }
    bool SetStaticMesh(UStaticMesh* NewMesh) { return NativeCall<bool, UStaticMesh*>(this, "UStaticMeshComponent.SetStaticMesh", NewMesh); }
    void GetLocalBounds(FVector* Min, FVector* Max) { NativeCall<void, FVector*, FVector*>(this, "UStaticMeshComponent.GetLocalBounds", Min, Max); }
    bool UsesOnlyUnlitMaterials() { return NativeCall<bool>(this, "UStaticMeshComponent.UsesOnlyUnlitMaterials"); }
    bool GetLightMapResolution(int* Width, int* Height) { return NativeCall<bool, int*, int*>(this, "UStaticMeshComponent.GetLightMapResolution", Width, Height); }
    void GetEstimatedLightMapResolution(int* Width, int* Height) { NativeCall<void, int*, int*>(this, "UStaticMeshComponent.GetEstimatedLightMapResolution", Width, Height); }
    bool HasValidSettingsForStaticLighting() { return NativeCall<bool>(this, "UStaticMeshComponent.HasValidSettingsForStaticLighting"); }
    bool UsesTextureLightmaps(int InWidth, int InHeight) { return NativeCall<bool, int, int>(this, "UStaticMeshComponent.UsesTextureLightmaps", 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", InWidth, InHeight, OutLightMapMemoryUsage, OutShadowMapMemoryUsage); }
    void GetLightAndShadowMapMemoryUsage(int* LightMapMemoryUsage, int* ShadowMapMemoryUsage) { NativeCall<void, int*, int*>(this, "UStaticMeshComponent.GetLightAndShadowMapMemoryUsage", 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", TextureLightMapMemoryUsage, TextureShadowMapMemoryUsage, VertexLightMapMemoryUsage, VertexShadowMapMemoryUsage, StaticLightingResolution, bIsUsingTextureMapping, bHasLightmapTexCoords); }
    int GetNumMaterials() { return NativeCall<int>(this, "UStaticMeshComponent.GetNumMaterials"); }
    void GetUsedMaterials(TArray<UMaterialInterface*>* OutMaterials) { NativeCall<void, TArray<UMaterialInterface*>*>(this, "UStaticMeshComponent.GetUsedMaterials", OutMaterials); }
    FName* GetComponentInstanceDataType(FName* result) { return NativeCall<FName*, FName*>(this, "UStaticMeshComponent.GetComponentInstanceDataType", result); }
    //void ApplyComponentInstanceData(TSharedPtr<FComponentInstanceDataBase, 0> ComponentInstanceData) { NativeCall<void, TSharedPtr<FComponentInstanceDataBase, 0>>(this, "UStaticMeshComponent.ApplyComponentInstanceData", ComponentInstanceData); }
    //bool DoCustomNavigableGeometryExport(FNavigableGeometryExport* GeomExport) { return NativeCall<bool, FNavigableGeometryExport*>(this, "UStaticMeshComponent.DoCustomNavigableGeometryExport", GeomExport); }
    //ELightMapInteractionType GetStaticLightingType() { return NativeCall<ELightMapInteractionType>(this, "UStaticMeshComponent.GetStaticLightingType"); }
    float GetEmissiveBoost(int ElementIndex) { return NativeCall<float, int>(this, "UStaticMeshComponent.GetEmissiveBoost", ElementIndex); }
    float GetDiffuseBoost(int ElementIndex) { return NativeCall<float, int>(this, "UStaticMeshComponent.GetDiffuseBoost", ElementIndex); }
    void InvalidateLightingCacheDetailed(bool bInvalidateBuildEnqueuedLighting, bool bTranslationOnly) { NativeCall<void, bool, bool>(this, "UStaticMeshComponent.InvalidateLightingCacheDetailed", bInvalidateBuildEnqueuedLighting, bTranslationOnly); }
    bool SetStaticLightingMapping(bool bTextureMapping, int ResolutionToUse) { return NativeCall<bool, bool, int>(this, "UStaticMeshComponent.SetStaticLightingMapping", bTextureMapping, ResolutionToUse); }
    void SetLODDataCount(const unsigned int MinSize, const unsigned int MaxSize) { NativeCall<void, const unsigned int, const unsigned int>(this, "UStaticMeshComponent.SetLODDataCount", MinSize, MaxSize); }
    bool ShouldRecreateProxyOnUpdateTransform() { return NativeCall<bool>(this, "UStaticMeshComponent.ShouldRecreateProxyOnUpdateTransform"); }
};
 
struct UInstancedStaticMeshComponent : UStaticMeshComponent
{
    void DealDirectDamage(APlayerController* ForPC, float DamageAmount, TSubclassOf<UDamageType> DamageTypeClass, int hitBodyIndex) { NativeCall<void, APlayerController*, float, TSubclassOf<UDamageType>, int>(this, "UInstancedStaticMeshComponent.DealDirectDamage", ForPC, DamageAmount, DamageTypeClass, hitBodyIndex); }
};
 
struct UStaticMeshSocket : UObject
{
    FName& SocketNameField() { return *GetNativePointerField<FName*>(this, "UStaticMeshSocket.SocketName"); }
    FVector& RelativeLocationField() { return *GetNativePointerField<FVector*>(this, "UStaticMeshSocket.RelativeLocation"); }
    FRotator& RelativeRotationField() { return *GetNativePointerField<FRotator*>(this, "UStaticMeshSocket.RelativeRotation"); }
    FVector& RelativeScaleField() { return *GetNativePointerField<FVector*>(this, "UStaticMeshSocket.RelativeScale"); }
    FString& TagField() { return *GetNativePointerField<FString*>(this, "UStaticMeshSocket.Tag"); }
 
    // Functions
 
    bool GetSocketTransform(FTransform* OutTransform, UStaticMeshComponent* MeshComp) { return NativeCall<bool, FTransform*, UStaticMeshComponent*>(this, "UStaticMeshSocket.GetSocketTransform", OutTransform, MeshComp); }
};
 
struct UStaticMesh : UObject
{
    TArray<UMaterialInterface*>& MaterialsField() { return *GetNativePointerField<TArray<UMaterialInterface*>*>(this, "UStaticMesh.Materials"); }
    //TScopedPointer<FStaticMeshRenderData>& RenderDataField() { return *GetNativePointerField<TScopedPointer<FStaticMeshRenderData>*>(this, "UStaticMesh.RenderData"); }
    int& LightMapResolutionField() { return *GetNativePointerField<int*>(this, "UStaticMesh.LightMapResolution"); }
    int& LightMapCoordinateIndexField() { return *GetNativePointerField<int*>(this, "UStaticMesh.LightMapCoordinateIndex"); }
    //TEnumAsByte<enum EDistanceFieldTwoSidedOverride>& DistanceFieldTwoSidedOverrideField() { return *GetNativePointerField<TEnumAsByte<enum EDistanceFieldTwoSidedOverride>*>(this, "UStaticMesh.DistanceFieldTwoSidedOverride"); }
    float& DistanceFieldRuntimeQualityField() { return *GetNativePointerField<float*>(this, "UStaticMesh.DistanceFieldRuntimeQuality"); }
    int& CurrentStreamedInSizeField() { return *GetNativePointerField<int*>(this, "UStaticMesh.CurrentStreamedInSize"); }
    bool& bStreamInStateField() { return *GetNativePointerField<bool*>(this, "UStaticMesh.bStreamInState"); }
    bool& bStreamInRequestField() { return *GetNativePointerField<bool*>(this, "UStaticMesh.bStreamInRequest"); }
    unsigned __int64& RequestLoadField() { return *GetNativePointerField<unsigned __int64*>(this, "UStaticMesh.RequestLoad"); }
    //FThreadSafeCounter& PendingLODRequestField() { return *GetNativePointerField<FThreadSafeCounter*>(this, "UStaticMesh.PendingLODRequest"); }
    long double& LastStreamChangeCallField() { return *GetNativePointerField<long double*>(this, "UStaticMesh.LastStreamChangeCall"); }
    //TLinkedList<IAbstractStreamer*>* LinkedStreamersField() { return GetNativePointerField<TLinkedList<IAbstractStreamer*>*>(this, "UStaticMesh.LinkedStreamers"); }
    float& StreamingDistanceMultiplierField() { return *GetNativePointerField<float*>(this, "UStaticMesh.StreamingDistanceMultiplier"); }
    float& LpvBiasMultiplierField() { return *GetNativePointerField<float*>(this, "UStaticMesh.LpvBiasMultiplier"); }
    //FRenderCommandFence& ReleaseResourcesFenceField() { return *GetNativePointerField<FRenderCommandFence*>(this, "UStaticMesh.ReleaseResourcesFence"); }
    FString& HighResSourceMeshNameField() { return *GetNativePointerField<FString*>(this, "UStaticMesh.HighResSourceMeshName"); }
    unsigned int& HighResSourceMeshCRCField() { return *GetNativePointerField<unsigned int*>(this, "UStaticMesh.HighResSourceMeshCRC"); }
    FGuid& LightingGuidField() { return *GetNativePointerField<FGuid*>(this, "UStaticMesh.LightingGuid"); }
    TArray<UStaticMeshSocket*>& SocketsField() { return *GetNativePointerField<TArray<UStaticMeshSocket*>*>(this, "UStaticMesh.Sockets"); }
    //TSharedPtr<FSpeedTreeWind, 0>& SpeedTreeWindField() { return *GetNativePointerField<TSharedPtr<FSpeedTreeWind, 0>*>(this, "UStaticMesh.SpeedTreeWind"); }
    long double& LastRenderTimeField() { return *GetNativePointerField<long double*>(this, "UStaticMesh.LastRenderTime"); }
    float& ClosestDistanceField() { return *GetNativePointerField<float*>(this, "UStaticMesh.ClosestDistance"); }
    unsigned int& StreamDistanceFrameField() { return *GetNativePointerField<unsigned int*>(this, "UStaticMesh.StreamDistanceFrame"); }
    int& ElementToIgnoreForTexFactorField() { return *GetNativePointerField<int*>(this, "UStaticMesh.ElementToIgnoreForTexFactor"); }
    TArray<UAssetUserData*>& AssetUserDataField() { return *GetNativePointerField<TArray<UAssetUserData*>*>(this, "UStaticMesh.AssetUserData"); }
    //UNavCollision* NavCollisionField() { return GetNativePointerField<UNavCollision*>(this, "UStaticMesh.NavCollision"); }
    FName& CustomTagField() { return *GetNativePointerField<FName*>(this, "UStaticMesh.CustomTag"); }
 
    // Functions
 
    void InitResources() { NativeCall<void>(this, "UStaticMesh.InitResources"); }
    //unsigned __int64 GetResourceSize(EResourceSizeMode::Type Mode) { return NativeCall<unsigned __int64, EResourceSizeMode::Type>(this, "UStaticMesh.GetResourceSize", Mode); }
    bool HasValidRenderData() { return NativeCall<bool>(this, "UStaticMesh.HasValidRenderData"); }
    FBoxSphereBounds* GetBounds(FBoxSphereBounds* result) { return NativeCall<FBoxSphereBounds*, FBoxSphereBounds*>(this, "UStaticMesh.GetBounds", result); }
    float GetStreamingTextureFactor(int RequestedUVIndex) { return NativeCall<float, int>(this, "UStaticMesh.GetStreamingTextureFactor", RequestedUVIndex); }
    void ReleaseResources() { NativeCall<void>(this, "UStaticMesh.ReleaseResources"); }
    //static void AddReferencedObjects(UObject* InThis, FReferenceCollector* Collector) { NativeCall<void, UObject*, FReferenceCollector*>(nullptr, "UStaticMesh.AddReferencedObjects", InThis, Collector); }
    void BeginDestroy() { NativeCall<void>(this, "UStaticMesh.BeginDestroy"); }
    bool IsReadyForFinishDestroy() { return NativeCall<bool>(this, "UStaticMesh.IsReadyForFinishDestroy"); }
    //void GetAssetRegistryTags(TArray<UObject::FAssetRegistryTag>* OutTags) { NativeCall<void, TArray<UObject::FAssetRegistryTag>*>(this, "UStaticMesh.GetAssetRegistryTags", OutTags); }
    void Serialize(FArchive* Ar) { NativeCall<void, FArchive*>(this, "UStaticMesh.Serialize", Ar); }
    void PostLoad() { NativeCall<void>(this, "UStaticMesh.PostLoad"); }
    FString* GetDesc(FString* result) { return NativeCall<FString*, FString*>(this, "UStaticMesh.GetDesc", result); }
    bool ContainsPhysicsTriMeshData(bool bInUseAllTriData) { return NativeCall<bool, bool>(this, "UStaticMesh.ContainsPhysicsTriMeshData", bInUseAllTriData); }
    void AddAssetUserData(UAssetUserData* InUserData) { NativeCall<void, UAssetUserData*>(this, "UStaticMesh.AddAssetUserData", InUserData); }
    UAssetUserData* GetAssetUserDataOfClass(TSubclassOf<UAssetUserData> InUserDataClass) { return NativeCall<UAssetUserData*, TSubclassOf<UAssetUserData>>(this, "UStaticMesh.GetAssetUserDataOfClass", InUserDataClass); }
    void RemoveUserDataOfClass(TSubclassOf<UAssetUserData> InUserDataClass) { NativeCall<void, TSubclassOf<UAssetUserData>>(this, "UStaticMesh.RemoveUserDataOfClass", InUserDataClass); }
    void EnforceLightmapRestrictions() { NativeCall<void>(this, "UStaticMesh.EnforceLightmapRestrictions"); }
    void UnlinkStreaming() { NativeCall<void>(this, "UStaticMesh.UnlinkStreaming"); }
    void ResetStreamingState() { NativeCall<void>(this, "UStaticMesh.ResetStreamingState"); }
    void SetLODStreaming(long double CurrentAppTime) { NativeCall<void, long double>(this, "UStaticMesh.SetLODStreaming", CurrentAppTime); }
    long double Dyn_GetLastRenderTime() { return NativeCall<long double>(this, "UStaticMesh.Dyn_GetLastRenderTime"); }
    float Dyn_GetSizePriority() { return NativeCall<float>(this, "UStaticMesh.Dyn_GetSizePriority"); }
    void Dyn_SetStreaming(bool bShouldStream) { NativeCall<void, bool>(this, "UStaticMesh.Dyn_SetStreaming", bShouldStream); }
    int Dyn_GetStreamingSize() { return NativeCall<int>(this, "UStaticMesh.Dyn_GetStreamingSize"); }
    bool Dyn_IsStreamed() { return NativeCall<bool>(this, "UStaticMesh.Dyn_IsStreamed"); }
    bool UpdateStreaming() { return NativeCall<bool>(this, "UStaticMesh.UpdateStreaming"); }
    void InitializeLODData() { NativeCall<void>(this, "UStaticMesh.InitializeLODData"); }
};
 
struct FAttachedInstancedHarvestingElement
{
    UMeshComponent* BaseMeshComponent;
    int OriginalIndexIntoBase;
    float MaxHarvestHealth;
    float CurrentHarvestHealth;
    float HarvestDamageCache;
    float HarvestEffectivenessCache;
    UPrimalHarvestingComponent* ParentHarvestingComponent;
    FVector Position;
    __int8 bIsUnharvestable : 1;
    __int8 bUseInternalActorComponentOctree : 1;
    __int8 bRegisteredInternalActorComponentOctree : 1;
    __int8 bHarvestingComponentHidden : 1;
    __int8 bDontRegisterWithOctree : 1;
    long double LastDepletionTime;
    long double LastReplenishTime;
    float DepletionExhaustionEffect;
    float NextReplenishInterval;
    TArray<UActorComponent*> AdditionalComponentAttachments;
};
 
struct FComponentAttachmentEntry
{
    TSubclassOf<UActorComponent> ActorComponentClass;
    FVector ComponentLocationOffset;
    FRotator ComponentRotationOffset;
};
 
struct UPrimalHarvestingComponent : UActorComponent
{
    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "UPrimalHarvestingComponent.GetPrivateStaticClass", Package); }
    static void StaticRegisterNativesUPrimalHarvestingComponent() { NativeCall<void>(nullptr, "UPrimalHarvestingComponent.StaticRegisterNativesUPrimalHarvestingComponent"); }
    bool TemplateCheckForHarvestRepopulation(bool bForceReinit, UWorld* world, FVector* where) { NativeCall<bool, UWorld*, FVector*>(this, "UPrimalHarvestingComponent.TemplateCheckForHarvestRepopulation", world, where); }
    void DealDirectDamage(APlayerController* ForPC, float DamageAmount, TSubclassOf<UDamageType> DamageTypeClass) { NativeCall<void, APlayerController*, float, TSubclassOf<UDamageType>>(this, "UPrimalHarvestingComponent.DealDirectDamage", ForPC, DamageAmount, DamageTypeClass); }
 
    TArray<FHarvestResourceEntry>& HarvestResourceEntries() { return *GetNativePointerField<TArray<FHarvestResourceEntry>*>(this, "UPrimalHarvestingComponent.HarvestResourceEntries"); }
    TArray<FHarvestResourceEntry>& BaseHarvestResourceEntries() { return *GetNativePointerField<TArray<FHarvestResourceEntry>*>(this, "UPrimalHarvestingComponent.BaseHarvestResourceEntries"); }
 
    FString& DescriptiveName() { return *GetNativePointerField<FString*>(this, "UPrimalHarvestingComponent.DescriptiveName"); }
    FString& UseHarvestString() { return *GetNativePointerField<FString*>(this, "UPrimalHarvestingComponent.UseHarvestString"); }
    FString& UnequipWeaponToUseHarvestString() { return *GetNativePointerField<FString*>(this, "UPrimalHarvestingComponent.UnequipWeaponToUseHarvestString"); }
    FString& HarvestableFriendlyName() { return *GetNativePointerField<FString*>(this, "UPrimalHarvestingComponent.HarvestableFriendlyName"); }
    FAttachedInstancedHarvestingElement* ActiveInstancedElement() { return *GetNativePointerField<FAttachedInstancedHarvestingElement**>(this, "UPrimalHarvestingComponent.ActiveInstancedElement"); }
 
    TArray<FComponentAttachmentEntry>& AdditionalComponentAttachments() { return *GetNativePointerField< TArray<FComponentAttachmentEntry>*>(this, "UPrimalHarvestingComponent.AdditionalComponentAttachments"); }
};
 
struct AMissionType : AActor
{
    FString& MissionDisplayNameField() { return *GetNativePointerField<FString*>(this, "AMissionType.MissionDisplayName"); }
 
    int& MissionVersionField() { return *GetNativePointerField<int*>(this, "AMissionType.MissionVersion"); }
    FName& CachedMissionTagField() { return *GetNativePointerField<FName*>(this, "AMissionType.CachedMissionTag"); }
 
    static void GetNearbyPlayersAndTamedDinos(UObject* WorldContextObject, TArray<APrimalCharacter*>* OutCharacters, FVector* Location, float Radius) { NativeCall<void, UObject*, TArray<APrimalCharacter*>*, FVector*, float>(nullptr, "AMissionType.GetNearbyPlayersAndTamedDinos", WorldContextObject, OutCharacters, Location, Radius); }
};
 
struct FCharacterAndControllerPair
{
    AShooterCharacter* Character;
    AShooterPlayerController* Controller;
};
 
struct ABiomeZoneVolume : AVolume
{
    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "ABiomeZoneVolume.GetPrivateStaticClass", Package); }
};
 
struct FSpawnPointInfo
{
    int& SpawnPointIDField() { return *GetNativePointerField<int*>(this, "FSpawnPointInfo.SpawnPointID"); }
    FString& BedNameField() { return *GetNativePointerField<FString*>(this, "FSpawnPointInfo.BedName"); }
    ABiomeZoneVolume* SpawnPointVolumeField() { return GetNativePointerField<ABiomeZoneVolume*>(this, "FSpawnPointInfo.SpawnPointVolume"); }
    FVector& AtLocationField() { return *GetNativePointerField<FVector*>(this, "FSpawnPointInfo.AtLocation"); }
    long double& NextAllowedUseTimeField() { return *GetNativePointerField<long double*>(this, "FSpawnPointInfo.NextAllowedUseTime"); }
    bool& bAllowedUseField() { return *GetNativePointerField<bool*>(this, "FSpawnPointInfo.bAllowedUse"); }
 
    // Functions
 
    FString* GetDisplayName(FString* result, FVector* FromPos, bool bIncludeDistance) { return NativeCall<FString*, FString*, FVector*, bool>(this, "FSpawnPointInfo.GetDisplayName", result, FromPos, bIncludeDistance); }
    FSpawnPointInfo* operator=(FSpawnPointInfo* __that) { return NativeCall<FSpawnPointInfo*, FSpawnPointInfo*>(this, "FSpawnPointInfo.operator=", __that); }
    bool operator==(FSpawnPointInfo* Other) { return NativeCall<bool, FSpawnPointInfo*>(this, "FSpawnPointInfo.operator==", Other); }
};
 
struct ATriggerBase : AActor
{
    static UClass* GetPrivateStaticClass() { return NativeCall<UClass*>(nullptr, "ATriggerBase.GetPrivateStaticClass"); }
    TSubobjectPtr<UShapeComponent>& CollisionComponentField() { return *GetNativePointerField<TSubobjectPtr<UShapeComponent>*>(this, "ATriggerBase.CollisionComponent"); }
};
 
struct ATriggerSphere : ATriggerBase
{
    static UClass* GetClass()
    {
        static UClass* Class = Globals::FindClass("Class /Script/Engine.TriggerSphere");
 
        return Class;
    }
};