ase/_atlas_2_actor_8h_source.html

#pragma once


#include "../Base.h"

#include <API/UE/Containers/TIndirectArray.h>


struct APrimalStructureBed;


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 UNetConnection

{

    //TArray<UChildConnection*> ChildrenField() { return *GetNativePointerField<TArray<UChildConnection*>*>(this, "UNetConnection.Children"); }

    //TSharedPtr<FClassNetCacheMgr, 0>& NetCacheField() { return *GetNativePointerField<TSharedPtr<FClassNetCacheMgr, 0>*>(this, "UNetConnection.NetCache"); }

    TArray<AActor*> SentTemporariesField() { return *GetNativePointerField<TArray<AActor*>*>(this, "UNetConnection.SentTemporaries"); }

    FVector& LastDormancyLocCheckField() { return *GetNativePointerField<FVector*>(this, "UNetConnection.LastDormancyLocCheck"); }

    float& PlayerControllerTimerField() { return *GetNativePointerField<float*>(this, "UNetConnection.PlayerControllerTimer"); }

    long double& SpatialFrameField() { return *GetNativePointerField<long double*>(this, "UNetConnection.SpatialFrame"); }

    long double& NextSpatialFrameCheckTimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.NextSpatialFrameCheckTime"); }

    AActor* ViewerField() { return *GetNativePointerField<AActor**>(this, "UNetConnection.Viewer"); }

    AActor* OwningActorField() { return *GetNativePointerField<AActor**>(this, "UNetConnection.OwningActor"); }

    int& MaxPacketField() { return *GetNativePointerField<int*>(this, "UNetConnection.MaxPacket"); }

    bool& bDeterminedIfRequiresHandShakeField() { return *GetNativePointerField<bool*>(this, "UNetConnection.bDeterminedIfRequiresHandShake"); }

    bool& bRequiresHandShakeField() { return *GetNativePointerField<bool*>(this, "UNetConnection.bRequiresHandShake"); }

    bool& bDoneHandshakingField() { return *GetNativePointerField<bool*>(this, "UNetConnection.bDoneHandshaking"); }

    //ConnectionSecurity* ConnSecurityField() { return *GetNativePointerField<ConnectionSecurity**>(this, "UNetConnection.ConnSecurity"); }

    //EConnectionState& StateField() { return *GetNativePointerField<EConnectionState*>(this, "UNetConnection.State"); }

    //EConnectionType::Type& ConnectionTypeField() { return *GetNativePointerField<EConnectionType::Type*>(this, "UNetConnection.ConnectionType"); }

    bool& bNeedsByteSwappingField() { return *GetNativePointerField<bool*>(this, "UNetConnection.bNeedsByteSwapping"); }

    TSharedPtr<FUniqueNetId, 0>& PlayerIdField() { return *GetNativePointerField<TSharedPtr<FUniqueNetId, 0>*>(this, "UNetConnection.PlayerId"); }

    int& ProtocolVersionField() { return *GetNativePointerField<int*>(this, "UNetConnection.ProtocolVersion"); }

    int& PacketOverheadField() { return *GetNativePointerField<int*>(this, "UNetConnection.PacketOverhead"); }

    FString& ChallengeField() { return *GetNativePointerField<FString*>(this, "UNetConnection.Challenge"); }

    FString& ClientResponseField() { return *GetNativePointerField<FString*>(this, "UNetConnection.ClientResponse"); }

    int& ResponseIdField() { return *GetNativePointerField<int*>(this, "UNetConnection.ResponseId"); }

    int& NegotiatedVerField() { return *GetNativePointerField<int*>(this, "UNetConnection.NegotiatedVer"); }

    FString& RequestURLField() { return *GetNativePointerField<FString*>(this, "UNetConnection.RequestURL"); }

    //EClientLoginState::Type& ClientLoginStateField() { return *GetNativePointerField<EClientLoginState::Type*>(this, "UNetConnection.ClientLoginState"); }

    char& ExpectedClientLoginMsgTypeField() { return *GetNativePointerField<char*>(this, "UNetConnection.ExpectedClientLoginMsgType"); }

    FString& CDKeyHashField() { return *GetNativePointerField<FString*>(this, "UNetConnection.CDKeyHash"); }

    FString& CDKeyResponseField() { return *GetNativePointerField<FString*>(this, "UNetConnection.CDKeyResponse"); }

    long double& LastReceiveTimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.LastReceiveTime"); }

    long double& LastSendTimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.LastSendTime"); }

    long double& LastTickTimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.LastTickTime"); }

    int& QueuedBytesField() { return *GetNativePointerField<int*>(this, "UNetConnection.QueuedBytes"); }

    int& TickCountField() { return *GetNativePointerField<int*>(this, "UNetConnection.TickCount"); }

    float& LastRecvAckTimeField() { return *GetNativePointerField<float*>(this, "UNetConnection.LastRecvAckTime"); }

    float& ConnectTimeField() { return *GetNativePointerField<float*>(this, "UNetConnection.ConnectTime"); }

    //FBitWriterMark& LastStartField() { return *GetNativePointerField<FBitWriterMark*>(this, "UNetConnection.LastStart"); }

    //FBitWriterMark& LastEndField() { return *GetNativePointerField<FBitWriterMark*>(this, "UNetConnection.LastEnd"); }

    bool& AllowMergeField() { return *GetNativePointerField<bool*>(this, "UNetConnection.AllowMerge"); }

    bool& TimeSensitiveField() { return *GetNativePointerField<bool*>(this, "UNetConnection.TimeSensitive"); }

    long double& StatUpdateTimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.StatUpdateTime"); }

    float& StatPeriodField() { return *GetNativePointerField<float*>(this, "UNetConnection.StatPeriod"); }

    float& BestLagField() { return *GetNativePointerField<float*>(this, "UNetConnection.BestLag"); }

    float& AvgLagField() { return *GetNativePointerField<float*>(this, "UNetConnection.AvgLag"); }

    float& LagAccField() { return *GetNativePointerField<float*>(this, "UNetConnection.LagAcc"); }

    float& BestLagAccField() { return *GetNativePointerField<float*>(this, "UNetConnection.BestLagAcc"); }

    int& LagCountField() { return *GetNativePointerField<int*>(this, "UNetConnection.LagCount"); }

    long double& LastTimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.LastTime"); }

    long double& FrameTimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.FrameTime"); }

    long double& CumulativeTimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.CumulativeTime"); }

    long double& AverageFrameTimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.AverageFrameTime"); }

    int& CountedFramesField() { return *GetNativePointerField<int*>(this, "UNetConnection.CountedFrames"); }

    int& InBytesField() { return *GetNativePointerField<int*>(this, "UNetConnection.InBytes"); }

    int& OutBytesField() { return *GetNativePointerField<int*>(this, "UNetConnection.OutBytes"); }

    int& InPacketsLostField() { return *GetNativePointerField<int*>(this, "UNetConnection.InPacketsLost"); }

    int& OutPacketsLostField() { return *GetNativePointerField<int*>(this, "UNetConnection.OutPacketsLost"); }

    //FBitWriter& SendBufferField() { return *GetNativePointerField<FBitWriter*>(this, "UNetConnection.SendBuffer"); }

    FieldArray<long double, 256> OutLagTimeField() { return { this, "UNetConnection.OutLagTime" }; }

    FieldArray<int, 256> OutLagPacketIdField() { return { this, "UNetConnection.OutLagPacketId" }; }

    int& InPacketIdField() { return *GetNativePointerField<int*>(this, "UNetConnection.InPacketId"); }

    int& OutPacketIdField() { return *GetNativePointerField<int*>(this, "UNetConnection.OutPacketId"); }

    int& OutAckPacketIdField() { return *GetNativePointerField<int*>(this, "UNetConnection.OutAckPacketId"); }

    int& PartialPacketIdField() { return *GetNativePointerField<int*>(this, "UNetConnection.PartialPacketId"); }

    int& LastPartialPacketIdField() { return *GetNativePointerField<int*>(this, "UNetConnection.LastPartialPacketId"); }

    FieldArray<unsigned int, 1024> PingAckDataCacheField() { return { this, "UNetConnection.PingAckDataCache" }; }

    float& LastPingAckField() { return *GetNativePointerField<float*>(this, "UNetConnection.LastPingAck"); }

    int& LastPingAckPacketIdField() { return *GetNativePointerField<int*>(this, "UNetConnection.LastPingAckPacketId"); }

    FieldArray<int, 10240> OutReliableField() { return { this, "UNetConnection.OutReliable" }; }

    FieldArray<int, 10240> InReliableField() { return { this, "UNetConnection.InReliable" }; }

    FieldArray<int, 10240> PendingOutRecField() { return { this, "UNetConnection.PendingOutRec" }; }

    TArray<int>& QueuedAcksField() { return *GetNativePointerField<TArray<int>*>(this, "UNetConnection.QueuedAcks"); }

    TArray<int>& ResendAcksField() { return *GetNativePointerField<TArray<int>*>(this, "UNetConnection.ResendAcks"); }

    long double& LogCallLastTimeField() { return *GetNativePointerField<long double*>(this, "UNetConnection.LogCallLastTime"); }

    int& LogCallCountField() { return *GetNativePointerField<int*>(this, "UNetConnection.LogCallCount"); }

    int& LogSustainedCountField() { return *GetNativePointerField<int*>(this, "UNetConnection.LogSustainedCount"); }

    //TMap<AActor const*, FActorChannelData, FDefaultSetAllocator, TDefaultMapKeyFuncs<AActor const*, FActorChannelData, 0> > ActorChannelsField() { return *GetNativePointerField<TMap<AActor const*, FActorChannelData, FDefaultSetAllocator, TDefaultMapKeyFuncs<AActor const*, FActorChannelData, 0> >*>(this, "UNetConnection.ActorChannels"); }

    TSet<AActor const*, DefaultKeyFuncs<AActor const*, 0>, FDefaultSetAllocator> DormantActorsField() { return *GetNativePointerField<TSet<AActor const*, DefaultKeyFuncs<AActor const*, 0>, FDefaultSetAllocator>*>(this, "UNetConnection.DormantActors"); }

    TSet<AActor const*, DefaultKeyFuncs<AActor const*, 0>, FDefaultSetAllocator> PendingDormantActorsField() { return *GetNativePointerField<TSet<AActor const*, DefaultKeyFuncs<AActor const*, 0>, FDefaultSetAllocator>*>(this, "UNetConnection.PendingDormantActors"); }

    TSet<AActor const*, DefaultKeyFuncs<AActor const*, 0>, FDefaultSetAllocator> DormantActorsNoParentField() { return *GetNativePointerField<TSet<AActor const*, DefaultKeyFuncs<AActor const*, 0>, FDefaultSetAllocator>*>(this, "UNetConnection.DormantActorsNoParent"); }

    TSet<AActor const*, DefaultKeyFuncs<AActor const*, 0>, FDefaultSetAllocator> PendingDormantActorsNoParentField() { return *GetNativePointerField<TSet<AActor const*, DefaultKeyFuncs<AActor const*, 0>, FDefaultSetAllocator>*>(this, "UNetConnection.PendingDormantActorsNoParent"); }

    float& DormancyRateField() { return *GetNativePointerField<float*>(this, "UNetConnection.DormancyRate"); }

    TSet<AActor*, DefaultKeyFuncs<AActor*, 0>, FDefaultSetAllocator> PendingProcessingDormantActor_FarField() { return *GetNativePointerField<TSet<AActor*, DefaultKeyFuncs<AActor*, 0>, FDefaultSetAllocator>*>(this, "UNetConnection.PendingProcessingDormantActor_Far"); }

    TSet<AActor*, DefaultKeyFuncs<AActor*, 0>, FDefaultSetAllocator> PendingProcessingDormantActor_NearField() { return *GetNativePointerField<TSet<AActor*, DefaultKeyFuncs<AActor*, 0>, FDefaultSetAllocator>*>(this, "UNetConnection.PendingProcessingDormantActor_Near"); }

    unsigned int& PerPacketTinyTokenToSendField() { return *GetNativePointerField<unsigned int*>(this, "UNetConnection.PerPacketTinyTokenToSend"); }

    unsigned int& PerPacketTinyTokenToRecieveField() { return *GetNativePointerField<unsigned int*>(this, "UNetConnection.PerPacketTinyTokenToRecieve"); }

    FString& ClientGivenIPField() { return *GetNativePointerField<FString*>(this, "UNetConnection.ClientGivenIP"); }

    bool& bSetupFailMessageField() { return *GetNativePointerField<bool*>(this, "UNetConnection.bSetupFailMessage"); }

    bool& bSharedConnectionField() { return *GetNativePointerField<bool*>(this, "UNetConnection.bSharedConnection"); }

    TSet<AActor const*, DefaultKeyFuncs<AActor const*, 0>, FDefaultSetAllocator> RecentlyDormantActorsField() { return *GetNativePointerField<TSet<AActor const*, DefaultKeyFuncs<AActor const*, 0>, FDefaultSetAllocator>*>(this, "UNetConnection.RecentlyDormantActors"); }

    //TMap<TWeakObjectPtr<UObject>, TSharedRef<FObjectReplicator, 1>, FDefaultSetAllocator, TDefaultMapKeyFuncs<TWeakObjectPtr<UObject>, TSharedRef<FObjectReplicator, 1>, 0> >& DormantReplicatorMapField() { return *GetNativePointerField<TMap<TWeakObjectPtr<UObject>, TSharedRef<FObjectReplicator, 1>, FDefaultSetAllocator, TDefaultMapKeyFuncs<TWeakObjectPtr<UObject>, TSharedRef<FObjectReplicator, 1>, 0> >*>(this, "UNetConnection.DormantReplicatorMap"); }

    TSet<FNetworkGUID, DefaultKeyFuncs<FNetworkGUID, 0>, FDefaultSetAllocator>& DestroyedStartupOrDormantActorsField() { return *GetNativePointerField<TSet<FNetworkGUID, DefaultKeyFuncs<FNetworkGUID, 0>, FDefaultSetAllocator>*>(this, "UNetConnection.DestroyedStartupOrDormantActors"); }

    FName& ClientWorldPackageNameField() { return *GetNativePointerField<FName*>(this, "UNetConnection.ClientWorldPackageName"); }

    TArray<FName>& ClientVisibleLevelNamesField() { return *GetNativePointerField<TArray<FName>*>(this, "UNetConnection.ClientVisibleLevelNames"); }

    TArray<AActor*> OwnedConsiderListField() { return *GetNativePointerField<TArray<AActor*>*>(this, "UNetConnection.OwnedConsiderList"); }


    // Bit fields


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

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

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

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

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


    // Functions


    int BattlEye_GetAddrAsInt() { return NativeCall<int>(this, "UNetConnection.BattlEye_GetAddrAsInt"); }

    UActorChannel* ActorChannelsFindRef(AActor* InActor, bool bUseWeak) { return NativeCall<UActorChannel*, AActor*, bool>(this, "UNetConnection.ActorChannelsFindRef", InActor, bUseWeak); }

    void CheckFirstActor() { NativeCall<void>(this, "UNetConnection.CheckFirstActor"); }

    void CleanUp() { NativeCall<void>(this, "UNetConnection.CleanUp"); }

    void CleanupDormantActorState() { NativeCall<void>(this, "UNetConnection.CleanupDormantActorState"); }

    bool ClientHasInitializedLevelFor(UObject* TestObject) { return NativeCall<bool, UObject*>(this, "UNetConnection.ClientHasInitializedLevelFor", TestObject); }

    void Close() { NativeCall<void>(this, "UNetConnection.Close"); }

    void FinishDestroy() { NativeCall<void>(this, "UNetConnection.FinishDestroy"); }

    void FlushDormancyForObject(UObject* Object) { NativeCall<void, UObject*>(this, "UNetConnection.FlushDormancyForObject", Object); }

    void FlushNet(bool bIgnoreSimulation) { NativeCall<void, bool>(this, "UNetConnection.FlushNet", bIgnoreSimulation); }

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

    //UBattlEyeChannel* GetBattlEyeChannel() { return NativeCall<UBattlEyeChannel*>(this, "UNetConnection.GetBattlEyeChannel"); }

    void HandleClientPlayer(APlayerController* PC, UNetConnection* NetConnection) { NativeCall<void, APlayerController*, UNetConnection*>(this, "UNetConnection.HandleClientPlayer", PC, NetConnection); }

    void InitSendBuffer() { NativeCall<void>(this, "UNetConnection.InitSendBuffer"); }

    bool IsClientMsgTypeValid(const char ClientMsgType) { return NativeCall<bool, const char>(this, "UNetConnection.IsClientMsgTypeValid", ClientMsgType); }

    int IsNetReady(bool Saturate) { return NativeCall<int, bool>(this, "UNetConnection.IsNetReady", Saturate); }

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

    FString* LowLevelGetRemoteAddress(FString* result, bool bAppendPort) { return NativeCall<FString*, FString*, bool>(this, "UNetConnection.LowLevelGetRemoteAddress", result, bAppendPort); }

    void LowLevelSend(void* Data, int Count) { NativeCall<void, void*, int>(this, "UNetConnection.LowLevelSend", Data, Count); }

    void PurgeAcks() { NativeCall<void>(this, "UNetConnection.PurgeAcks"); }

    void ReceivedNak(int NakPacketId) { NativeCall<void, int>(this, "UNetConnection.ReceivedNak", NakPacketId); }

    void ReceivedNak_Range(int NakPacketStart, int NakPacketEnd) { NativeCall<void, int, int>(this, "UNetConnection.ReceivedNak_Range", NakPacketStart, NakPacketEnd); }

    //void ReceivedPacket(FBitReader* Reader) { NativeCall<void, FBitReader*>(this, "UNetConnection.ReceivedPacket", Reader); }

    void ReceivedRawPacket(void* InData, int Count) { NativeCall<void, void*, int>(this, "UNetConnection.ReceivedRawPacket", InData, Count); }

    void ResetGameWorldState() { NativeCall<void>(this, "UNetConnection.ResetGameWorldState"); }

    void SendAck(int AckPacketId, bool FirstTime, bool bHavePingAckData, unsigned int PingAckData) { NativeCall<void, int, bool, bool, unsigned int>(this, "UNetConnection.SendAck", AckPacketId, FirstTime, bHavePingAckData, PingAckData); }

    void SendPackageMap() { NativeCall<void>(this, "UNetConnection.SendPackageMap"); }

    //void SetClientLoginState(EClientLoginState::Type NewState) { NativeCall<void, EClientLoginState::Type>(this, "UNetConnection.SetClientLoginState", NewState); }

    void SetExpectedClientLoginMsgType(const char NewType) { NativeCall<void, const char>(this, "UNetConnection.SetExpectedClientLoginMsgType", NewType); }

    bool ShouldReplicateVoicePacketFrom(FUniqueNetId* Sender, char ShouldUseSuperRange, char* playbackFlags) { return NativeCall<bool, FUniqueNetId*, char, char*>(this, "UNetConnection.ShouldReplicateVoicePacketFrom", Sender, ShouldUseSuperRange, playbackFlags); }

    void Tick() { NativeCall<void>(this, "UNetConnection.Tick"); }

    void ValidateSendBuffer() { NativeCall<void>(this, "UNetConnection.ValidateSendBuffer"); }

    int WriteBitsToSendBuffer(const char* Bits, const int SizeInBits, const char* ExtraBits, const int ExtraSizeInBits) { return NativeCall<int, const char*, const int, const char*, const int>(this, "UNetConnection.WriteBitsToSendBuffer", Bits, SizeInBits, ExtraBits, ExtraSizeInBits); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "UNetConnection.GetPrivateStaticClass", Package); }

};


struct FUniqueNetIdRepl

{

    TSharedPtr<FUniqueNetId> UniqueNetId;


    // Functions


    FUniqueNetIdRepl* operator=(FUniqueNetIdRepl* Other) { return NativeCall<FUniqueNetIdRepl*, FUniqueNetIdRepl*>(this, "FUniqueNetIdRepl.operator=", Other); }

    bool operator==(FUniqueNetIdRepl* Other) { return NativeCall<bool, FUniqueNetIdRepl*>(this, "FUniqueNetIdRepl.operator==", Other); }

    void SetUniqueNetId(TSharedPtr<FUniqueNetId, 0> * InUniqueNetId) { NativeCall<void, TSharedPtr<FUniqueNetId, 0>*>(this, "FUniqueNetIdRepl.SetUniqueNetId", InUniqueNetId); }

    bool ExportTextItem(FString* ValueStr, FUniqueNetIdRepl* DefaultValue, UObject* Parent, int PortFlags, UObject* ExportRootScope) { return NativeCall<bool, FString*, FUniqueNetIdRepl*, UObject*, int, UObject*>(this, "FUniqueNetIdRepl.ExportTextItem", ValueStr, DefaultValue, Parent, PortFlags, ExportRootScope); }

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

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

};


struct FPrimalPlayerCharacterConfigStructReplicated {};


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 FPrimalStats

{

    bool& bUsedField() { return *GetNativePointerField<bool*>(this, "FPrimalStats.bUsed"); }

    long double& StartStatsTimeField() { return *GetNativePointerField<long double*>(this, "FPrimalStats.StartStatsTime"); }

    FieldArray<int, 7> PrimalStatsValuesField() { return { this, "FPrimalStats.PrimalStatsValues" }; }


    // Functions


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

};


struct FSpawnPointInfo

{

    unsigned int& EntityIDField() { return *GetNativePointerField<unsigned int*>(this, "FSpawnPointInfo.EntityID"); }

    FString& EntityNameField() { return *GetNativePointerField<FString*>(this, "FSpawnPointInfo.EntityName"); }

    bool& bServerIsFullField() { return *GetNativePointerField<bool*>(this, "FSpawnPointInfo.bServerIsFull"); }

    TEnumAsByte<enum ETribeEntityType::Type>& EntityTypeField() { return *GetNativePointerField<TEnumAsByte<enum ETribeEntityType::Type>*>(this, "FSpawnPointInfo.EntityType"); }

    TEnumAsByte<enum EShipType::Type>& ShipTypeField() { return *GetNativePointerField<TEnumAsByte<enum EShipType::Type>*>(this, "FSpawnPointInfo.ShipType"); }

    unsigned int& ServerIdField() { return *GetNativePointerField<unsigned int*>(this, "FSpawnPointInfo.ServerId"); }

    FVector2D& RelativeLocationInServerField() { return *GetNativePointerField<FVector2D*>(this, "FSpawnPointInfo.RelativeLocationInServer"); }

    unsigned int& NextAllowedUseTimeField() { return *GetNativePointerField<unsigned int*>(this, "FSpawnPointInfo.NextAllowedUseTime"); }

    unsigned int& ParentEntityIDField() { return *GetNativePointerField<unsigned int*>(this, "FSpawnPointInfo.ParentEntityID"); }

    bool& bInLandClaimedFlagRangeField() { return *GetNativePointerField<bool*>(this, "FSpawnPointInfo.bInLandClaimedFlagRange"); }

    bool& bReachedMaxTravelCountField() { return *GetNativePointerField<bool*>(this, "FSpawnPointInfo.bReachedMaxTravelCount"); }

    bool& bIsDeadField() { return *GetNativePointerField<bool*>(this, "FSpawnPointInfo.bIsDead"); }


    // Functions


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

    FString* GetDisplayName(FString* result, FVector* FromPos, bool bIncludeDistance) { return NativeCall<FString*, FString*, FVector*, bool>(this, "FSpawnPointInfo.GetDisplayName", result, FromPos, bIncludeDistance); }

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

};


struct FAdminPlayerDataInfo

{

    FString& PlayerNameField() { return *GetNativePointerField<FString*>(this, "FAdminPlayerDataInfo.PlayerName"); }

    FString& PlayerSteamNameField() { return *GetNativePointerField<FString*>(this, "FAdminPlayerDataInfo.PlayerSteamName"); }

    FString& SteamIDField() { return *GetNativePointerField<FString*>(this, "FAdminPlayerDataInfo.SteamID"); }

    __int64& LinkedPlayerIDField() { return *GetNativePointerField<__int64*>(this, "FAdminPlayerDataInfo.LinkedPlayerID"); }

    bool& IsHostField() { return *GetNativePointerField<bool*>(this, "FAdminPlayerDataInfo.IsHost"); }


    // Functions


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

};


struct FPlayerDeathReason

{

    int& PlayerIDField() { return *GetNativePointerField<int*>(this, "FPlayerDeathReason.PlayerID"); }

    FString& DeathReasonField() { return *GetNativePointerField<FString*>(this, "FPlayerDeathReason.DeathReason"); }

    long double& DiedAtTimeField() { return *GetNativePointerField<long double*>(this, "FPlayerDeathReason.DiedAtTime"); }


    // Functions


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

};


struct FPrimalPlayerCharacterConfigStruct

{

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

    FLinearColor& OverrideHeadHairColorField() { return *GetNativePointerField<FLinearColor*>(this, "FPrimalPlayerCharacterConfigStruct.OverrideHeadHairColor"); }

    FLinearColor& OverrideFacialHairColorField() { return *GetNativePointerField<FLinearColor*>(this, "FPrimalPlayerCharacterConfigStruct.OverrideFacialHairColor"); }

    char& FacialHairIndexField() { return *GetNativePointerField<char*>(this, "FPrimalPlayerCharacterConfigStruct.FacialHairIndex"); }

    char& HeadHairIndexField() { return *GetNativePointerField<char*>(this, "FPrimalPlayerCharacterConfigStruct.HeadHairIndex"); }

    FString& PlayerCharacterFirstNameField() { return *GetNativePointerField<FString*>(this, "FPrimalPlayerCharacterConfigStruct.PlayerCharacterFirstName"); }

    FString& PlayerCharacterLastNameField() { return *GetNativePointerField<FString*>(this, "FPrimalPlayerCharacterConfigStruct.PlayerCharacterLastName"); }

    FieldArray<float, 66> BonePresetsField() { return { this, "FPrimalPlayerCharacterConfigStruct.BonePresets" }; }

    FieldArray<float, 1> AdvancedBoneModifiersField() { return { this, "FPrimalPlayerCharacterConfigStruct.AdvancedBoneModifiers" }; }

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

    float& BodyfatField() { return *GetNativePointerField<float*>(this, "FPrimalPlayerCharacterConfigStruct.Bodyfat"); }

    float& AgeField() { return *GetNativePointerField<float*>(this, "FPrimalPlayerCharacterConfigStruct.Age"); }

    float& MuscleToneField() { return *GetNativePointerField<float*>(this, "FPrimalPlayerCharacterConfigStruct.MuscleTone"); }


    // Bit fields


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


    // Functions


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

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

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

};


struct FPrimalCharacterStatusValueModifier

{

    TEnumAsByte<enum EPrimalCharacterStatusValue::Type>& ValueTypeField() { return *GetNativePointerField<TEnumAsByte<enum EPrimalCharacterStatusValue::Type>*>(this, "FPrimalCharacterStatusValueModifier.ValueType"); }

    TEnumAsByte<enum EPrimalCharacterStatusValue::Type>& StopOnValueNearMaxField() { return *GetNativePointerField<TEnumAsByte<enum EPrimalCharacterStatusValue::Type>*>(this, "FPrimalCharacterStatusValueModifier.StopOnValueNearMax"); }

    float& AmountToAddField() { return *GetNativePointerField<float*>(this, "FPrimalCharacterStatusValueModifier.AmountToAdd"); }

    float& BaseAmountToAddField() { return *GetNativePointerField<float*>(this, "FPrimalCharacterStatusValueModifier.BaseAmountToAdd"); }

    float& SpeedToAddField() { return *GetNativePointerField<float*>(this, "FPrimalCharacterStatusValueModifier.SpeedToAdd"); }

    int& StatusValueModifierDescriptionIndexField() { return *GetNativePointerField<int*>(this, "FPrimalCharacterStatusValueModifier.StatusValueModifierDescriptionIndex"); }


    // Bit fields


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

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

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

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

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

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


    // Functions


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

};


struct FDinoBaseLevelWeightEntry

{

    float& EntryWeightField() { return *GetNativePointerField<float*>(this, "FDinoBaseLevelWeightEntry.EntryWeight"); }

    float& BaseLevelMinRangeField() { return *GetNativePointerField<float*>(this, "FDinoBaseLevelWeightEntry.BaseLevelMinRange"); }

    float& BaseLevelMaxRangeField() { return *GetNativePointerField<float*>(this, "FDinoBaseLevelWeightEntry.BaseLevelMaxRange"); }


    // Functions


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

};


struct FClassRemappingWeight

{

    TSubclassOf<UObject> FromClass;

    TArray<TSubclassOf<UObject>> ToClasses;

    TArray<float> Weights;

};


struct FClassNameReplacement

{

    FString& FromClassNameField() { return *GetNativePointerField<FString*>(this, "FClassNameReplacement.FromClassName"); }

    FString& ToClassNameField() { return *GetNativePointerField<FString*>(this, "FClassNameReplacement.ToClassName"); }


    // Functions


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

};


struct FNPCDifficultyLevelRange

{

    TArray<float> EnemyLevelsMin;

    TArray<float> EnemyLevelsMax;

    TArray<float> GameDifficulties;

};


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;

  unsigned __int32 bForcePreventSpawnOnOcean : 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;

  float OverrideYaw;

};


struct FNPCSpawnLimit

{

    TSubclassOf<APrimalDinoCharacter> NPCClass;

    FString NPCClassString;

    float MaxPercentageOfDesiredNumToAllow;

    int CurrentNumberOfNPCTouching;

};


struct UNPCSpawnEntriesContainer : UObject

{

    FString& EntriesNameField() { return *GetNativePointerField<FString*>(this, "UNPCSpawnEntriesContainer.EntriesName"); }

    TArray<FNPCSpawnEntry>& NPCSpawnEntriesField() { return *GetNativePointerField<TArray<FNPCSpawnEntry>*>(this, "UNPCSpawnEntriesContainer.NPCSpawnEntries"); }

    TArray<FNPCSpawnLimit>& NPCSpawnLimitsField() { return *GetNativePointerField<TArray<FNPCSpawnLimit>*>(this, "UNPCSpawnEntriesContainer.NPCSpawnLimits"); }

    float& MaxDesiredNumEnemiesMultiplierField() { return *GetNativePointerField<float*>(this, "UNPCSpawnEntriesContainer.MaxDesiredNumEnemiesMultiplier"); }

    bool& bForceLinkedVolumesToOnlyCountMyDinoClassesField() { return *GetNativePointerField<bool*>(this, "UNPCSpawnEntriesContainer.bForceLinkedVolumesToOnlyCountMyDinoClasses"); }

    int& bOverrideLinkedVolume_OnlyCountWaterDinosField() { return *GetNativePointerField<int*>(this, "UNPCSpawnEntriesContainer.bOverrideLinkedVolume_OnlyCountWaterDinos"); }

    int& bOverrideLinkedVolume_OnlyCountLandDinosField() { return *GetNativePointerField<int*>(this, "UNPCSpawnEntriesContainer.bOverrideLinkedVolume_OnlyCountLandDinos"); }

    int& bOverrideLinkedVolume_CountTamedDinosField() { return *GetNativePointerField<int*>(this, "UNPCSpawnEntriesContainer.bOverrideLinkedVolume_CountTamedDinos"); }


    // Functions


    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "UNPCSpawnEntriesContainer.GetPrivateStaticClass", Package); }

};


struct FNPCSpawnEntriesContainerAdditions

{

    TSubclassOf<UNPCSpawnEntriesContainer> SpawnEntriesContainerClass;

    TArray<FNPCSpawnEntry> AdditionalNPCSpawnEntries;

    TArray<FNPCSpawnLimit> AdditionalNPCSpawnLimits;

};


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" }; }


    // Functions


    FVector* GetCustomLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "USceneComponent.GetCustomLocation", result); }

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

    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 AddWorldOffset(FVector DeltaLocation, bool bSweep) { NativeCall<void, FVector, bool>(this, "USceneComponent.AddWorldOffset", DeltaLocation, bSweep); }

    void AddWorldRotation(FRotator DeltaRotation, bool bSweep) { NativeCall<void, FRotator, bool>(this, "USceneComponent.AddWorldRotation", DeltaRotation, bSweep); }

    void AddWorldTransform(FTransform* DeltaTransform, bool bSweep) { NativeCall<void, FTransform*, bool>(this, "USceneComponent.AddWorldTransform", DeltaTransform, bSweep); }

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

    void ApplyWorldOffset(FVector* InOffset, bool bWorldShift) { NativeCall<void, FVector*, bool>(this, "USceneComponent.ApplyWorldOffset", InOffset, bWorldShift); }

    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 BeginDestroy() { NativeCall<void>(this, "USceneComponent.BeginDestroy"); }

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

    FBoxSphereBounds* CalcBounds(FBoxSphereBounds* result, FTransform* LocalToWorld) { return NativeCall<FBoxSphereBounds*, FBoxSphereBounds*, FTransform*>(this, "USceneComponent.CalcBounds", result, LocalToWorld); }

    FTransform* CalcNewComponentToWorld(FTransform* result, FTransform* NewRelativeTransform, USceneComponent* Parent) { return NativeCall<FTransform*, FTransform*, FTransform*, USceneComponent*>(this, "USceneComponent.CalcNewComponentToWorld", result, NewRelativeTransform, Parent); }

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

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

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

    unsigned __int64 GetAttachParent() { return NativeCall<unsigned __int64>(this, "USceneComponent.GetAttachParent"); }

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

    AActor* GetAttachmentRootActor() { return NativeCall<AActor*>(this, "USceneComponent.GetAttachmentRootActor"); }

    USceneComponent* GetChildComponent(int ChildIndex) { return NativeCall<USceneComponent*, int>(this, "USceneComponent.GetChildComponent", ChildIndex); }

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

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

    FVector* GetComponentVelocity(FVector* result) { return NativeCall<FVector*, FVector*>(this, "USceneComponent.GetComponentVelocity", result); }

    FVector* GetForwardVector(FVector* result) { return NativeCall<FVector*, FVector*>(this, "USceneComponent.GetForwardVector", result); }

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

    FVector* GetMeshScaleMultiplier(FVector* result) { return NativeCall<FVector*, FVector*>(this, "USceneComponent.GetMeshScaleMultiplier", result); }

    int GetNumChildrenComponents() { return NativeCall<int>(this, "USceneComponent.GetNumChildrenComponents"); }

    void GetParentComponents(TArray<USceneComponent*>* Parents) { NativeCall<void, TArray<USceneComponent*>*>(this, "USceneComponent.GetParentComponents", Parents); }

    FBoxSphereBounds* GetPlacementExtent(FBoxSphereBounds* result) { return NativeCall<FBoxSphereBounds*, FBoxSphereBounds*>(this, "USceneComponent.GetPlacementExtent", result); }

    FTransform* GetRelativeTransform(FTransform* result) { return NativeCall<FTransform*, FTransform*>(this, "USceneComponent.GetRelativeTransform", result); }

    FVector* GetRightVector(FVector* result) { return NativeCall<FVector*, FVector*>(this, "USceneComponent.GetRightVector", result); }

    FVector* GetSocketLocation(FVector* result, FName SocketName) { return NativeCall<FVector*, FVector*, FName>(this, "USceneComponent.GetSocketLocation", result, SocketName); }

    FQuat* GetSocketQuaternion(FQuat* result, FName SocketName) { return NativeCall<FQuat*, FQuat*, FName>(this, "USceneComponent.GetSocketQuaternion", result, SocketName); }

    FRotator* GetSocketRotation(FRotator* result, FName SocketName) { return NativeCall<FRotator*, FRotator*, FName>(this, "USceneComponent.GetSocketRotation", result, SocketName); }

    FTransform* GetSocketTransform(FTransform* result, FName SocketName, ERelativeTransformSpace TransformSpace) { return NativeCall<FTransform*, FTransform*, FName, ERelativeTransformSpace>(this, "USceneComponent.GetSocketTransform", result, SocketName, TransformSpace); }

    void GetSocketWorldLocationAndRotation(FName InSocketName, FVector* OutLocation, FQuat* OutRotation) { NativeCall<void, FName, FVector*, FQuat*>(this, "USceneComponent.GetSocketWorldLocationAndRotation", InSocketName, OutLocation, OutRotation); }

    void GetSocketWorldLocationAndRotation(FName InSocketName, FVector* OutLocation, FRotator* OutRotation) { NativeCall<void, FName, FVector*, FRotator*>(this, "USceneComponent.GetSocketWorldLocationAndRotation", InSocketName, OutLocation, OutRotation); }

    FVector* GetUpVector(FVector* result) { return NativeCall<FVector*, FVector*>(this, "USceneComponent.GetUpVector", result); }

    FVector* GetWorldLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "USceneComponent.GetWorldLocation", result); }

    bool InternalSetWorldLocationAndRotation(FVector NewLocation, FQuat* RotationQuat, bool bNoPhysics) { return NativeCall<bool, FVector, FQuat*, bool>(this, "USceneComponent.InternalSetWorldLocationAndRotation", NewLocation, RotationQuat, bNoPhysics); }

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

    bool IsAttachedTo(USceneComponent* TestComp) { return NativeCall<bool, USceneComponent*>(this, "USceneComponent.IsAttachedTo", TestComp); }

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

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

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

    void K2_AttachTo(USceneComponent* InParent, FName InSocketName, EAttachLocation::Type AttachLocationType, bool bWeldSimulatedBodies) { NativeCall<void, USceneComponent*, FName, EAttachLocation::Type, bool>(this, "USceneComponent.K2_AttachTo", InParent, InSocketName, AttachLocationType, bWeldSimulatedBodies); }

    FRotator* K2_GetComponentRotation(FRotator* result) { return NativeCall<FRotator*, FRotator*>(this, "USceneComponent.K2_GetComponentRotation", result); }

    FVector* K2_GetComponentScale(FVector* result) { return NativeCall<FVector*, FVector*>(this, "USceneComponent.K2_GetComponentScale", result); }

    FTransform* K2_GetComponentToWorld(FTransform* result) { return NativeCall<FTransform*, FTransform*>(this, "USceneComponent.K2_GetComponentToWorld", result); }

    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); }

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

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

    void OnRep_Visibility(bool OldValue) { NativeCall<void, bool>(this, "USceneComponent.OnRep_Visibility", OldValue); }

    void PostInterpChange(UProperty* PropertyThatChanged) { NativeCall<void, UProperty*>(this, "USceneComponent.PostInterpChange", PropertyThatChanged); }

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

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

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

    void SetAbsolute(bool bNewAbsoluteLocation, bool bNewAbsoluteRotation, bool bNewAbsoluteScale) { NativeCall<void, bool, bool, bool>(this, "USceneComponent.SetAbsolute", bNewAbsoluteLocation, bNewAbsoluteRotation, bNewAbsoluteScale); }

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

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

    void SetRelativeLocationAndRotation(FVector NewLocation, FQuat* NewRotation, bool bSweep) { NativeCall<void, FVector, FQuat*, bool>(this, "USceneComponent.SetRelativeLocationAndRotation", NewLocation, NewRotation, bSweep); }

    void SetRelativeScale3D(FVector NewScale3D) { NativeCall<void, FVector>(this, "USceneComponent.SetRelativeScale3D", NewScale3D); }

    void SetRelativeTransform(FTransform* NewTransform, bool bSweep) { NativeCall<void, FTransform*, bool>(this, "USceneComponent.SetRelativeTransform", NewTransform, bSweep); }

    void SetVisibility(bool bNewVisibility, bool bPropagateToChildren) { NativeCall<void, bool, bool>(this, "USceneComponent.SetVisibility", bNewVisibility, bPropagateToChildren); }

    void SetWorldLocation(FVector NewLocation, bool bSweep) { NativeCall<void, FVector, bool>(this, "USceneComponent.SetWorldLocation", NewLocation, bSweep); }

    void SetWorldLocationAndRotation(FVector NewLocation, FQuat* NewRotation, bool bSweep) { NativeCall<void, FVector, FQuat*, bool>(this, "USceneComponent.SetWorldLocationAndRotation", NewLocation, NewRotation, bSweep); }

    void SetWorldLocationAndRotation(FVector NewLocation, FRotator NewRotation, bool bSweep) { NativeCall<void, FVector, FRotator, bool>(this, "USceneComponent.SetWorldLocationAndRotation", NewLocation, NewRotation, bSweep); }

    void SetWorldLocationAndRotationNoPhysics(FVector* NewLocation, FRotator* NewRotation) { NativeCall<void, FVector*, FRotator*>(this, "USceneComponent.SetWorldLocationAndRotationNoPhysics", NewLocation, NewRotation); }

    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); }

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

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

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

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

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

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

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

    void UpdateComponentToWorld(bool bSkipPhysicsMove) { NativeCall<void, bool>(this, "USceneComponent.UpdateComponentToWorld", bSkipPhysicsMove); }

    void UpdateComponentToWorldWithParent(USceneComponent* Parent, bool bSkipPhysicsMove, FQuat* RelativeRotationQuat) { NativeCall<void, USceneComponent*, bool, FQuat*>(this, "USceneComponent.UpdateComponentToWorldWithParent", Parent, bSkipPhysicsMove, RelativeRotationQuat); }

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

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

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

    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"); }

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

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

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

    FVector& InterpolatedRootLocationField() { return *GetNativePointerField<FVector*>(this, "UPrimitiveComponent.InterpolatedRootLocation"); }

    FRotator& InterpolatedRootRotationField() { return *GetNativePointerField<FRotator*>(this, "UPrimitiveComponent.InterpolatedRootRotation"); }

    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"); }

    FieldArray<char, 2> RBSyncModuloField() { return { this, "UPrimitiveComponent.RBSyncModulo" }; }

    FieldArray<char, 2> RBSyncOffsetField() { return { this, "UPrimitiveComponent.RBSyncOffset" }; }

    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"); }

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

    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> bForceExcludeFromGlobalDistanceField() { return { this, "UPrimitiveComponent.bForceExcludeFromGlobalDistanceField" }; }

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

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

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

    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> IgnoreDuringPlanarReflectionPass() { return { this, "UPrimitiveComponent.IgnoreDuringPlanarReflectionPass" }; }

    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> bClimbable() { return { this, "UPrimitiveComponent.bClimbable" }; }

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

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

    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 AreSymmetricRotations(FQuat* A, FQuat* B, FVector* Scale3D) { return NativeCall<bool, FQuat*, FQuat*, FVector*>(this, "UPrimitiveComponent.AreSymmetricRotations", A, B, Scale3D); }

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

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

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

    void GetLightAndShadowMapMemoryUsage(int* NumInstances, float* BoundsSurfaceArea) { NativeCall<void, int*, float*>(this, "UPrimitiveComponent.GetLightAndShadowMapMemoryUsage", NumInstances, BoundsSurfaceArea); }

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

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

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

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

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

    bool ComponentOverlapComponentImpl(UPrimitiveComponent* PrimComp, FVector Pos, FQuat* Quat, FCollisionQueryParams* Params) { return NativeCall<bool, UPrimitiveComponent*, FVector, FQuat*, FCollisionQueryParams*>(this, "UPrimitiveComponent.ComponentOverlapComponentImpl", PrimComp, Pos, Quat, Params); }

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

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

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

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

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

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

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

    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 DispatchOnReleased() { NativeCall<void>(this, "UPrimitiveComponent.DispatchOnReleased"); }

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

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

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

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

    TArray<TWeakObjectPtr<AActor>>* GetMoveIgnoreActors() { return NativeCall<TArray<TWeakObjectPtr<AActor>>*>(this, "UPrimitiveComponent.GetMoveIgnoreActors"); }

    FBox* GetNavigationBounds(FBox* result) { return NativeCall<FBox*, FBox*>(this, "UPrimitiveComponent.GetNavigationBounds", result); }

    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); }

    static float GetRBSync_StartDistance() { return NativeCall<float>(nullptr, "UPrimitiveComponent.GetRBSync_StartDistance"); }

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

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

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

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

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

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

    bool IsIgnoringActorWhileMoving(AActor* ForActor) { return NativeCall<bool, AActor*>(this, "UPrimitiveComponent.IsIgnoringActorWhileMoving", ForActor); }

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

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

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

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

    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 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); }

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

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

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

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

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

    void OnUpdateTransform(bool bSkipPhysicsMove) { NativeCall<void, bool>(this, "UPrimitiveComponent.OnUpdateTransform", bSkipPhysicsMove); }

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

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

    bool PrimitiveContainsPoint(FVector* Point) { return NativeCall<bool, FVector*>(this, "UPrimitiveComponent.PrimitiveContainsPoint", Point); }

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

    void SendPhysicsTransform(bool bTeleport) { NativeCall<void, bool>(this, "UPrimitiveComponent.SendPhysicsTransform", bTeleport); }

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

    void SetAbsoluteMaxDrawScale(bool bInValue) { NativeCall<void, bool>(this, "UPrimitiveComponent.SetAbsoluteMaxDrawScale", bInValue); }

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

    void SetCastShadow(bool NewCastShadow) { NativeCall<void, bool>(this, "UPrimitiveComponent.SetCastShadow", NewCastShadow); }

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

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

    void SetDepthPriorityGroup(ESceneDepthPriorityGroup NewDepthPriorityGroup) { NativeCall<void, ESceneDepthPriorityGroup>(this, "UPrimitiveComponent.SetDepthPriorityGroup", NewDepthPriorityGroup); }

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

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

    void SetRenderCustomDepth(bool bValue) { NativeCall<void, bool>(this, "UPrimitiveComponent.SetRenderCustomDepth", bValue); }

    void SetTranslucentSortPriority(int NewTranslucentSortPriority) { NativeCall<void, int>(this, "UPrimitiveComponent.SetTranslucentSortPriority", NewTranslucentSortPriority); }

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

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

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

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

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

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

    void AddForce(FVector Force, FName BoneName, bool bAllowSubstepping) { NativeCall<void, FVector, FName, bool>(this, "UPrimitiveComponent.AddForce", Force, BoneName, bAllowSubstepping); }

    void AddForceAtLocation(FVector Force, FVector Location, FName BoneName, bool bAllowSubstepping) { NativeCall<void, FVector, FVector, FName, bool>(this, "UPrimitiveComponent.AddForceAtLocation", Force, Location, BoneName, bAllowSubstepping); }

    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 AddRadialForce(FVector Origin, float Radius, float Strength, ERadialImpulseFalloff Falloff) { NativeCall<void, FVector, float, float, ERadialImpulseFalloff>(this, "UPrimitiveComponent.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, "UPrimitiveComponent.AddRadialImpulse", Origin, Radius, Strength, Falloff, bVelChange); }

    void AddTorque(FVector Torque, FName BoneName, bool bAllowSubstepping) { NativeCall<void, FVector, FName, bool>(this, "UPrimitiveComponent.AddTorque", Torque, BoneName, bAllowSubstepping); }

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

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

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

    FVector* GetCenterOfMass(FVector* result, FName BoneName) { return NativeCall<FVector*, FVector*, FName>(this, "UPrimitiveComponent.GetCenterOfMass", result, BoneName); }

    ECollisionEnabled::Type GetCollisionEnabled() { return NativeCall<ECollisionEnabled::Type>(this, "UPrimitiveComponent.GetCollisionEnabled"); }

    FName* GetCollisionProfileName(FName* result) { return NativeCall<FName*, FName*>(this, "UPrimitiveComponent.GetCollisionProfileName", result); }

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

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

    FVector* GetComponentVelocity(FVector* result) { return NativeCall<FVector*, FVector*>(this, "UPrimitiveComponent.GetComponentVelocity", result); }

    float GetDistanceToCollision(FVector* Point, FVector* ClosestPointOnCollision) { return NativeCall<float, FVector*, FVector*>(this, "UPrimitiveComponent.GetDistanceToCollision", Point, ClosestPointOnCollision); }

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

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

    FVector* GetPhysicsAngularVelocity(FVector* result, FName BoneName) { return NativeCall<FVector*, FVector*, FName>(this, "UPrimitiveComponent.GetPhysicsAngularVelocity", result, BoneName); }

    FVector* GetPhysicsLinearVelocity(FVector* result, FName BoneName) { return NativeCall<FVector*, FVector*, FName>(this, "UPrimitiveComponent.GetPhysicsLinearVelocity", result, BoneName); }

    FVector* GetPhysicsLinearVelocityAtPoint(FVector* result, FVector Point, FName BoneName) { return NativeCall<FVector*, FVector*, FVector, FName>(this, "UPrimitiveComponent.GetPhysicsLinearVelocityAtPoint", result, Point, BoneName); }

    FWalkableSlopeOverride* GetWalkableSlopeOverride() { return NativeCall<FWalkableSlopeOverride*>(this, "UPrimitiveComponent.GetWalkableSlopeOverride"); }

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

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

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

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

    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); }

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

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

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

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

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

    void SetAllPhysicsAngularVelocity(FVector* NewAngVel, bool bAddToCurrent) { NativeCall<void, FVector*, bool>(this, "UPrimitiveComponent.SetAllPhysicsAngularVelocity", NewAngVel, bAddToCurrent); }

    void SetAllPhysicsLinearVelocity(FVector NewVel, bool bAddToCurrent) { NativeCall<void, FVector, bool>(this, "UPrimitiveComponent.SetAllPhysicsLinearVelocity", NewVel, bAddToCurrent); }

    void SetAllPhysicsPosition(FVector NewPos) { NativeCall<void, FVector>(this, "UPrimitiveComponent.SetAllPhysicsPosition", NewPos); }

    void SetAllPhysicsRotation(FRotator NewRot) { NativeCall<void, FRotator>(this, "UPrimitiveComponent.SetAllPhysicsRotation", NewRot); }

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

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

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

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

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

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

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

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

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

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

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

    void SetPhysicsAngularVelocity(FVector NewAngVel, bool bAddToCurrent, FName BoneName) { NativeCall<void, FVector, bool, FName>(this, "UPrimitiveComponent.SetPhysicsAngularVelocity", NewAngVel, bAddToCurrent, BoneName); }

    void SetPhysicsLinearVelocity(FVector NewVel, bool bAddToCurrent, FName BoneName) { NativeCall<void, FVector, bool, FName>(this, "UPrimitiveComponent.SetPhysicsLinearVelocity", NewVel, bAddToCurrent, BoneName); }

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

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

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

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

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

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

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

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

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

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "UPrimitiveComponent.GetPrivateStaticClass", Package); }

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

};


struct UShapeComponent : UPrimitiveComponent

{

    FColor& ShapeColorField() { return *GetNativePointerField<FColor*>(this, "UShapeComponent.ShapeColor"); }

    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"); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "UShapeComponent.GetPrivateStaticClass", Package); }

};


struct USphereComponent : UShapeComponent

{

    float& SphereRadiusField() { return *GetNativePointerField<float*>(this, "USphereComponent.SphereRadius"); }


    // Functions


    bool AreSymmetricRotations(FQuat* A, FQuat* B, FVector* Scale3D) { return NativeCall<bool, FQuat*, FQuat*, FVector*>(this, "USphereComponent.AreSymmetricRotations", A, B, Scale3D); }

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

    FBoxSphereBounds* CalcBounds(FBoxSphereBounds* result, FTransform* LocalToWorld) { return NativeCall<FBoxSphereBounds*, FBoxSphereBounds*, FTransform*>(this, "USphereComponent.CalcBounds", result, LocalToWorld); }

    bool IsZeroExtent() { return NativeCall<bool>(this, "USphereComponent.IsZeroExtent"); }

    bool PrimitiveContainsPoint(FVector* Point) { return NativeCall<bool, FVector*>(this, "USphereComponent.PrimitiveContainsPoint", Point); }

    void SetSphereRadius(float InSphereRadius, bool bUpdateOverlaps) { NativeCall<void, float, bool>(this, "USphereComponent.SetSphereRadius", InSphereRadius, bUpdateOverlaps); }

    void UpdateBodySetup() { NativeCall<void>(this, "USphereComponent.UpdateBodySetup"); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "USphereComponent.GetPrivateStaticClass", Package); }

    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"); }

    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"); }

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

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

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

    TArray<AActor*> NetworkSpatializationChildrenField() { return *GetNativePointerField<TArray<AActor*>*>(this, "AActor.NetworkSpatializationChildren"); }

    TArray<AActor*> NetworkSpatializationChildrenDormantField() { return *GetNativePointerField<TArray<AActor*>*>(this, "AActor.NetworkSpatializationChildrenDormant"); }

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

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

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

    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"); }

    unsigned int& UniqueActorIdField() { return *GetNativePointerField<unsigned int*>(this, "AActor.UniqueActorId"); }

    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"); }

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

    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"); }

    FVector& DefaultActorLocationField() { return *GetNativePointerField<FVector*>(this, "AActor.DefaultActorLocation"); }

    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"); }

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

    int& LastFrameCalculcatedNetworkRangeMultiplierField() { return *GetNativePointerField<int*>(this, "AActor.LastFrameCalculcatedNetworkRangeMultiplier"); }

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

    bool& bShouldSendPartialBunchesOverThresholdAsReliableField() { return *GetNativePointerField<bool*>(this, "AActor.bShouldSendPartialBunchesOverThresholdAsReliable"); }


    // 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> bIgnoreNetworkRangeScaling() { return { this, "AActor.bIgnoreNetworkRangeScaling" }; }

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

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

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

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

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

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

    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> bOverrideMultiUseCenterText() { return { this, "AActor.bOverrideMultiUseCenterText" }; }

    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> 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" }; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


    // Functions


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

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

    FVector* GetTargetingLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AActor.GetTargetingLocation", result); }

    bool IsMarkedForSeamlessTravel() { return NativeCall<bool>(this, "AActor.IsMarkedForSeamlessTravel"); }

    void UnmarkAbortedForSeamlessTravel() { NativeCall<void>(this, "AActor.UnmarkAbortedForSeamlessTravel"); }

    bool IsLevelBoundsRelevant() { return NativeCall<bool>(this, "AActor.IsLevelBoundsRelevant"); }

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

    bool HasAuthority() { return NativeCall<bool>(this, "AActor.HasAuthority"); }

    bool IsPendingKillPending() { return NativeCall<bool>(this, "AActor.IsPendingKillPending"); }

    void MarkForSeamlessTravel(unsigned int DestinationServerId, ESeamlessVolumeSide::Side DestinationServerVolumeSide) { NativeCall<void, unsigned int, ESeamlessVolumeSide::Side>(this, "AActor.MarkForSeamlessTravel", DestinationServerId, DestinationServerVolumeSide); }

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

    void AddActorLocalOffset(FVector DeltaLocation, bool bSweep) { NativeCall<void, FVector, bool>(this, "AActor.AddActorLocalOffset", DeltaLocation, bSweep); }

    void AddActorLocalRotation(FRotator DeltaRotation, bool bSweep) { NativeCall<void, FRotator, bool>(this, "AActor.AddActorLocalRotation", DeltaRotation, bSweep); }

    void AddActorLocalTransform(FTransform* NewTransform, bool bSweep) { NativeCall<void, FTransform*, bool>(this, "AActor.AddActorLocalTransform", NewTransform, bSweep); }

    void AddActorWorldOffset(FVector DeltaLocation, bool bSweep) { NativeCall<void, FVector, bool>(this, "AActor.AddActorWorldOffset", DeltaLocation, bSweep); }

    void AddActorWorldRotation(FRotator DeltaRotation, bool bSweep) { NativeCall<void, FRotator, bool>(this, "AActor.AddActorWorldRotation", DeltaRotation, bSweep); }

    void AddActorWorldTransform(FTransform* DeltaTransform, bool bSweep) { NativeCall<void, FTransform*, bool>(this, "AActor.AddActorWorldTransform", DeltaTransform, bSweep); }

    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 AddControllingMatineeActor(AMatineeActor* InMatineeActor) { NativeCall<void, AMatineeActor*>(this, "AActor.AddControllingMatineeActor", InMatineeActor); }

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

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

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

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

    bool AlwaysReplicatePropertyConditional(UProperty* forProperty) { return NativeCall<bool, UProperty*>(this, "AActor.AlwaysReplicatePropertyConditional", forProperty); }

    void ApplyWorldOffset(FVector* InOffset, bool bWorldShift) { NativeCall<void, FVector*, bool>(this, "AActor.ApplyWorldOffset", InOffset, bWorldShift); }

    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 AttachRootComponentToActor(AActor* InParentActor, FName InSocketName, EAttachLocation::Type AttachLocationType, bool bWeldSimulatedBodies) { NativeCall<void, AActor*, FName, EAttachLocation::Type, bool>(this, "AActor.AttachRootComponentToActor", InParentActor, InSocketName, AttachLocationType, bWeldSimulatedBodies); }

    bool BPIsA(TSubclassOf<AActor> anActorClass) { return NativeCall<bool, TSubclassOf<AActor>>(this, "AActor.BPIsA", anActorClass); }

    bool BPIsMarkedForSeamlessTravel() { return NativeCall<bool>(this, "AActor.BPIsMarkedForSeamlessTravel"); }

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

    void BecomeViewTarget(APlayerController* PC) { NativeCall<void, APlayerController*>(this, "AActor.BecomeViewTarget", PC); }

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

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

    void CalcCamera(float DeltaTime, FMinimalViewInfo* OutResult) { NativeCall<void, float, FMinimalViewInfo*>(this, "AActor.CalcCamera", DeltaTime, OutResult); }

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

    bool CheckActorComponents() { return NativeCall<bool>(this, "AActor.CheckActorComponents"); }

    bool CheckDefaultSubobjectsInternal() { return NativeCall<bool>(this, "AActor.CheckDefaultSubobjectsInternal"); }

    bool CheckStillInWorld() { return NativeCall<bool>(this, "AActor.CheckStillInWorld"); }

    void ClearCrossLevelReferences() { NativeCall<void>(this, "AActor.ClearCrossLevelReferences"); }

    void ClearNetworkSpatializationParent() { NativeCall<void>(this, "AActor.ClearNetworkSpatializationParent"); }

    void ClientIsAboutToSeamlessTravel() { NativeCall<void>(this, "AActor.ClientIsAboutToSeamlessTravel"); }

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

    void CopyRemoteRoleFrom(AActor* CopyFromActor) { NativeCall<void, AActor*>(this, "AActor.CopyRemoteRoleFrom", CopyFromActor); }

    void CreateChildActors() { NativeCall<void>(this, "AActor.CreateChildActors"); }

    UActorComponent* CreateComponentFromTemplate(UActorComponent* Template, FString* InName) { return NativeCall<UActorComponent*, UActorComponent*, FString*>(this, "AActor.CreateComponentFromTemplate", Template, InName); }

    bool Destroy(bool bNetForce, bool bShouldModifyLevel) { return NativeCall<bool, bool, bool>(this, "AActor.Destroy", bNetForce, bShouldModifyLevel); }

    void DestroyChildActors() { NativeCall<void>(this, "AActor.DestroyChildActors"); }

    void DestroyConstructedComponents() { NativeCall<void>(this, "AActor.DestroyConstructedComponents"); }

    void DestroyInput(APlayerController* PlayerController) { NativeCall<void, APlayerController*>(this, "AActor.DestroyInput", PlayerController); }

    void DestroyMeNextFrame() { NativeCall<void>(this, "AActor.DestroyMeNextFrame"); }

    void Destroyed() { NativeCall<void>(this, "AActor.Destroyed"); }

    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); }

    void DisableComponentsSimulatePhysics() { NativeCall<void>(this, "AActor.DisableComponentsSimulatePhysics"); }

    void DisableInput(APlayerController* PlayerController) { NativeCall<void, APlayerController*>(this, "AActor.DisableInput", PlayerController); }

    void DispatchBlockingHit(UPrimitiveComponent* MyComp, UPrimitiveComponent* OtherComp, bool bSelfMoved, FHitResult* Hit) { NativeCall<void, UPrimitiveComponent*, UPrimitiveComponent*, bool, FHitResult*>(this, "AActor.DispatchBlockingHit", MyComp, OtherComp, bSelfMoved, Hit); }

    void DoExecuteActorConstruction(FTransform* Transform, bool bIsDefaultTransform) { NativeCall<void, FTransform*, bool>(this, "AActor.DoExecuteActorConstruction", Transform, bIsDefaultTransform); }

    void EnableInput(APlayerController* PlayerController) { NativeCall<void, APlayerController*>(this, "AActor.EnableInput", PlayerController); }

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

    void EndViewTarget(APlayerController* PC) { NativeCall<void, APlayerController*>(this, "AActor.EndViewTarget", PC); }

    void ExchangeNetRoles(bool bRemoteOwned) { NativeCall<void, bool>(this, "AActor.ExchangeNetRoles", bRemoteOwned); }

    void FellOutOfWorld(UDamageType* dmgType) { NativeCall<void, UDamageType*>(this, "AActor.FellOutOfWorld", dmgType); }

    void FinalSeamlessTravelled() { NativeCall<void>(this, "AActor.FinalSeamlessTravelled"); }

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

    void FinishSpawning(FTransform* Transform, bool bIsDefaultTransform) { NativeCall<void, FTransform*, bool>(this, "AActor.FinishSpawning", Transform, bIsDefaultTransform); }

    void FlushNetDormancy() { NativeCall<void>(this, "AActor.FlushNetDormancy"); }

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

    void ForceNetRelevant() { NativeCall<void>(this, "AActor.ForceNetRelevant"); }

    void ForceReplicateNowWithChannel() { NativeCall<void>(this, "AActor.ForceReplicateNowWithChannel"); }

    void GetActorBounds(bool bOnlyCollidingComponents, FVector* Origin, FVector* BoxExtent) { NativeCall<void, bool, FVector*, FVector*>(this, "AActor.GetActorBounds", bOnlyCollidingComponents, Origin, BoxExtent); }

    bool GetActorEnableCollision() { return NativeCall<bool>(this, "AActor.GetActorEnableCollision"); }

    FVector* GetActorForwardVector(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AActor.GetActorForwardVector", result); }

    FVector* GetActorRelativeScale3D(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AActor.GetActorRelativeScale3D", result); }

    FVector* GetActorRightVector(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AActor.GetActorRightVector", result); }

    FVector* GetActorScale3D(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AActor.GetActorScale3D", result); }

    float GetActorTimeDilation() { return NativeCall<float>(this, "AActor.GetActorTimeDilation"); }

    FVector* GetActorUpVector(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AActor.GetActorUpVector", result); }

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

    void GetAllSceneComponents(TArray<USceneComponent*>* OutComponents) { NativeCall<void, TArray<USceneComponent*>*>(this, "AActor.GetAllSceneComponents", OutComponents); }

    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); }

    UActorComponent* GetComponentByClass(TSubclassOf<UActorComponent> ComponentClass) { return NativeCall<UActorComponent*, TSubclassOf<UActorComponent>>(this, "AActor.GetComponentByClass", ComponentClass); }

    UActorComponent* GetComponentByCustomTag(FName TheTag) { return NativeCall<UActorComponent*, FName>(this, "AActor.GetComponentByCustomTag", TheTag); }

    void GetComponents(TArray<UActorComponent*>* OutComponents) { NativeCall<void, TArray<UActorComponent*>*>(this, "AActor.GetComponents", OutComponents); }

    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); }

    void GetComponentsBoundingCylinder(float* OutCollisionRadius, float* OutCollisionHalfHeight, bool bNonColliding) { NativeCall<void, float*, float*, bool>(this, "AActor.GetComponentsBoundingCylinder", OutCollisionRadius, OutCollisionHalfHeight, bNonColliding); }

    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); }

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

    float GetDistanceTo(AActor* OtherActor) { return NativeCall<float, AActor*>(this, "AActor.GetDistanceTo", OtherActor); }

    float GetDotProductTo(AActor* OtherActor) { return NativeCall<float, AActor*>(this, "AActor.GetDotProductTo", OtherActor); }

    FString* GetEditTextString_Implementation(FString* result, APlayerController* ForPC, UObject* AssociatedObject1, int ExtraID1, int ExtraID2) { return NativeCall<FString*, FString*, APlayerController*, UObject*, int, int>(this, "AActor.GetEditTextString_Implementation", result, ForPC, AssociatedObject1, ExtraID1, ExtraID2); }

    float GetHorizontalDistanceTo(AActor* OtherActor) { return NativeCall<float, AActor*>(this, "AActor.GetHorizontalDistanceTo", OtherActor); }

    float GetHorizontalDotProductTo(AActor* OtherActor) { return NativeCall<float, AActor*>(this, "AActor.GetHorizontalDotProductTo", OtherActor); }

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

    float GetInputAxisKeyValue(FKey InputAxisKey) { return NativeCall<float, FKey>(this, "AActor.GetInputAxisKeyValue", InputAxisKey); }

    float GetInputAxisValue(FName InputAxisName) { return NativeCall<float, FName>(this, "AActor.GetInputAxisValue", InputAxisName); }

    FVector* GetInputVectorAxisValue(FVector* result, FKey InputAxisKey) { return NativeCall<FVector*, FVector*, FKey>(this, "AActor.GetInputVectorAxisValue", result, InputAxisKey); }

    APawn* GetInstigator() { return NativeCall<APawn*>(this, "AActor.GetInstigator"); }

    AController* GetInstigatorController() { return NativeCall<AController*>(this, "AActor.GetInstigatorController"); }

    FVector* GetTargetPathfindingLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AActor.GetTargetPathfindingLocation", result); }

    FVector* GetInterpolatedVelocity(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AActor.GetInterpolatedVelocity", result); }

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

    long double GetLastRenderTime(bool ignoreShadow) { return NativeCall<long double, bool>(this, "AActor.GetLastRenderTime", ignoreShadow); }

    float GetLifeSpan() { return NativeCall<float>(this, "AActor.GetLifeSpan"); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "AActor.GetLifetimeReplicatedProps", OutLifetimeProps); }

    UNetConnection* GetNetConnection() { return NativeCall<UNetConnection*>(this, "AActor.GetNetConnection"); }

    UPlayer* GetNetOwningPlayer() { return NativeCall<UPlayer*>(this, "AActor.GetNetOwningPlayer"); }

    float GetNetPriority(FVector* ViewPos, FVector* ViewDir, APlayerController* Viewer, UActorChannel* InChannel, float Time, bool bLowBandwidth) { return NativeCall<float, FVector*, FVector*, APlayerController*, UActorChannel*, float, bool>(this, "AActor.GetNetPriority", ViewPos, ViewDir, Viewer, InChannel, Time, bLowBandwidth); }

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

    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); }

    APlayerController* GetOwnerController() { return NativeCall<APlayerController*>(this, "AActor.GetOwnerController"); }

    ENetRole GetRemoteRole() { return NativeCall<ENetRole>(this, "AActor.GetRemoteRole"); }

    void GetSimpleCollisionCylinder(float* CollisionRadius, float* CollisionHalfHeight) { NativeCall<void, float*, float*>(this, "AActor.GetSimpleCollisionCylinder", CollisionRadius, CollisionHalfHeight); }

    void GetSubobjectsWithStableNamesForNetworking(TArray<UObject*>* ObjList) { NativeCall<void, TArray<UObject*>*>(this, "AActor.GetSubobjectsWithStableNamesForNetworking", ObjList); }

    FTransform* GetTransform(FTransform* result) { return NativeCall<FTransform*, FTransform*>(this, "AActor.GetTransform", result); }

    FVector* GetVelocity(FVector* result, bool bIsForRagdoll) { return NativeCall<FVector*, FVector*, bool>(this, "AActor.GetVelocity", result, bIsForRagdoll); }

    float GetVerticalDistanceTo(AActor* OtherActor) { return NativeCall<float, AActor*>(this, "AActor.GetVerticalDistanceTo", OtherActor); }

    UPrimitiveComponent* GetVisibleComponentByClass(TSubclassOf<UPrimitiveComponent> ComponentClass) { return NativeCall<UPrimitiveComponent*, TSubclassOf<UPrimitiveComponent>>(this, "AActor.GetVisibleComponentByClass", ComponentClass); }

    UPrimitiveComponent* GetVisibleUnhiddenComponentByClass(TSubclassOf<UPrimitiveComponent> ComponentClass) { return NativeCall<UPrimitiveComponent*, TSubclassOf<UPrimitiveComponent>>(this, "AActor.GetVisibleUnhiddenComponentByClass", ComponentClass); }

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

    AWorldSettings* GetWorldSettings() { return NativeCall<AWorldSettings*>(this, "AActor.GetWorldSettings"); }

    bool HasNetOwner() { return NativeCall<bool>(this, "AActor.HasNetOwner"); }

    void InitializeComponents() { NativeCall<void>(this, "AActor.InitializeComponents"); }

    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 InvalidateLightingCacheDetailed(bool bTranslationOnly) { NativeCall<void, bool>(this, "AActor.InvalidateLightingCacheDetailed", bTranslationOnly); }

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

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

    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 IsInGameplayWorld() { return NativeCall<bool>(this, "AActor.IsInGameplayWorld"); }

    bool IsInOrOwnedBy(UObject* SomeOuter) { return NativeCall<bool, UObject*>(this, "AActor.IsInOrOwnedBy", SomeOuter); }

    bool IsInPersistentLevel(bool bIncludeLevelStreamingPersistent) { return NativeCall<bool, bool>(this, "AActor.IsInPersistentLevel", bIncludeLevelStreamingPersistent); }

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

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

    bool IsNetRelevantFor(APlayerController* RealViewer, AActor* Viewer, FVector* SrcLocation) { return NativeCall<bool, APlayerController*, AActor*, FVector*>(this, "AActor.IsNetRelevantFor", RealViewer, Viewer, SrcLocation); }

    bool IsNetStartupActor() { return NativeCall<bool>(this, "AActor.IsNetStartupActor"); }

    bool IsOwnedOrControlledBy(AActor* TestOwner) { return NativeCall<bool, AActor*>(this, "AActor.IsOwnedOrControlledBy", TestOwner); }

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

    bool IsRelevancyOwnerFor(AActor* ReplicatedActor, AActor* ActorOwner, AActor* ConnectionActor) { return NativeCall<bool, AActor*, AActor*, AActor*>(this, "AActor.IsRelevancyOwnerFor", ReplicatedActor, ActorOwner, ConnectionActor); }

    bool IsRootComponentCollisionRegistered() { return NativeCall<bool>(this, "AActor.IsRootComponentCollisionRegistered"); }

    bool IsRootComponentMovable() { return NativeCall<bool>(this, "AActor.IsRootComponentMovable"); }

    bool IsRootComponentStatic() { return NativeCall<bool>(this, "AActor.IsRootComponentStatic"); }

    bool IsRootComponentStationary() { return NativeCall<bool>(this, "AActor.IsRootComponentStationary"); }

    void K2_AttachRootComponentTo(USceneComponent* InParent, FName InSocketName, EAttachLocation::Type AttachLocationType, bool bWeldSimulatedBodies) { NativeCall<void, USceneComponent*, FName, EAttachLocation::Type, bool>(this, "AActor.K2_AttachRootComponentTo", InParent, InSocketName, AttachLocationType, bWeldSimulatedBodies); }

    void K2_AttachRootComponentToActor(AActor* InParentActor, FName InSocketName, EAttachLocation::Type AttachLocationType, bool bWeldSimulatedBodies) { NativeCall<void, AActor*, FName, EAttachLocation::Type, bool>(this, "AActor.K2_AttachRootComponentToActor", InParentActor, InSocketName, AttachLocationType, bWeldSimulatedBodies); }

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

    FRotator* K2_GetActorRotation(FRotator* result) { return NativeCall<FRotator*, FRotator*>(this, "AActor.K2_GetActorRotation", result); }

    USceneComponent* K2_GetRootComponent() { return NativeCall<USceneComponent*>(this, "AActor.K2_GetRootComponent"); }

    UWorld* K2_GetWorld() { return NativeCall<UWorld*>(this, "AActor.K2_GetWorld"); }

    bool K2_SetActorLocation(FVector NewLocation, bool bSweep) { return NativeCall<bool, FVector, bool>(this, "AActor.K2_SetActorLocation", NewLocation, bSweep); }

    bool K2_TeleportTo(FVector DestLocation, FRotator DestRotation, bool bSimpleTeleport) { return NativeCall<bool, FVector, FRotator, bool>(this, "AActor.K2_TeleportTo", DestLocation, DestRotation, bSimpleTeleport); }

    void OutsideWorldBounds() { NativeCall<void>(this, "AActor.OutsideWorldBounds"); }

    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); }

    void MarkComponentsAsPendingKill() { NativeCall<void>(this, "AActor.MarkComponentsAsPendingKill"); }

    void MarkComponentsRenderStateDirty() { NativeCall<void>(this, "AActor.MarkComponentsRenderStateDirty"); }

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

    bool Modify(bool bAlwaysMarkDirty) { return NativeCall<bool, bool>(this, "AActor.Modify", bAlwaysMarkDirty); }

    void Multi_DrawDebugCoordinateSystem_Implementation(FVector AxisLoc, FRotator AxisRot, float Scale, bool bPersistentLines, float LifeTime, char DepthPriority, float Thickness) { NativeCall<void, FVector, FRotator, float, bool, float, char, float>(this, "AActor.Multi_DrawDebugCoordinateSystem_Implementation", AxisLoc, AxisRot, Scale, bPersistentLines, LifeTime, DepthPriority, Thickness); }

    void Multi_DrawDebugDirectionalArrow_Implementation(FVector LineStart, FVector LineEnd, float ArrowSize, FColor ArrowColor, bool bPersistentLines, float LifeTime, char DepthPriority) { NativeCall<void, FVector, FVector, float, FColor, bool, float, char>(this, "AActor.Multi_DrawDebugDirectionalArrow_Implementation", LineStart, LineEnd, ArrowSize, ArrowColor, bPersistentLines, LifeTime, DepthPriority); }

    void Multi_DrawDebugLine_Implementation(FVector LineStart, FVector LineEnd, FColor LineColor, bool bPersistentLines, float LifeTime, char DepthPriority, float Thickness) { NativeCall<void, FVector, FVector, FColor, bool, float, char, float>(this, "AActor.Multi_DrawDebugLine_Implementation", LineStart, LineEnd, LineColor, bPersistentLines, LifeTime, DepthPriority, Thickness); }

    void Multi_DrawDebugSphere_Implementation(FVector Center, float Radius, int Segments, FColor SphereColor, bool bPersistentLines, float LifeTime, char DepthPriority) { NativeCall<void, FVector, float, int, FColor, bool, float, char>(this, "AActor.Multi_DrawDebugSphere_Implementation", Center, Radius, Segments, SphereColor, bPersistentLines, LifeTime, DepthPriority); }

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

    void MulticastPropertyToPlayer(FName PropertyName, APlayerController* PC, bool bUnreliable) { NativeCall<void, FName, APlayerController*, bool>(this, "AActor.MulticastPropertyToPlayer", PropertyName, PC, bUnreliable); }

    void NetActorSpawnActorUnreliable_Implementation(TSubclassOf<AActor> ActorClass, FVector AtLoc, FRotator AtRot, bool bIgnoreOnDedicatedServer, USceneComponent* AttachToComponent, FName BoneName, AActor* SpawnOwner) { NativeCall<void, TSubclassOf<AActor>, FVector, FRotator, bool, USceneComponent*, FName, AActor*>(this, "AActor.NetActorSpawnActorUnreliable_Implementation", ActorClass, AtLoc, AtRot, bIgnoreOnDedicatedServer, AttachToComponent, BoneName, SpawnOwner); }

    void NetActorSpawnActor_Implementation(TSubclassOf<AActor> ActorClass, FVector AtLoc, FRotator AtRot, bool bIgnoreOnDedicatedServer, USceneComponent* AttachToComponent, FName BoneName, AActor* SpawnOwner) { NativeCall<void, TSubclassOf<AActor>, FVector, FRotator, bool, USceneComponent*, FName, AActor*>(this, "AActor.NetActorSpawnActor_Implementation", ActorClass, AtLoc, AtRot, bIgnoreOnDedicatedServer, AttachToComponent, BoneName, SpawnOwner); }

    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"); }

    void Net_DrawDebugBox(FVector* Center, FVector* BoxExtent, FQuat* Rotation, FColor* BoxColor, bool bPersistentLines, float LifeTime, char DepthPriority) { NativeCall<void, FVector*, FVector*, FQuat*, FColor*, bool, float, char>(this, "AActor.Net_DrawDebugBox", Center, BoxExtent, Rotation, BoxColor, bPersistentLines, LifeTime, DepthPriority); }

    void Net_DrawDebugCapsule(FVector* Center, float HalfHeight, float Radius, FQuat* Rotation, FColor* CapsuleColor, bool bPersistentLines, float LifeTime, char DepthPriority) { NativeCall<void, FVector*, float, float, FQuat*, FColor*, bool, float, char>(this, "AActor.Net_DrawDebugCapsule", Center, HalfHeight, Radius, Rotation, CapsuleColor, bPersistentLines, LifeTime, DepthPriority); }

    void Net_DrawDebugCoordinateSystem(FVector* AxisLoc, FRotator* AxisRot, float Scale, bool bPersistentLines, float LifeTime, char DepthPriority, float Thickness) { NativeCall<void, FVector*, FRotator*, float, bool, float, char, float>(this, "AActor.Net_DrawDebugCoordinateSystem", AxisLoc, AxisRot, Scale, bPersistentLines, LifeTime, DepthPriority, Thickness); }

    void Net_DrawDebugDirectionalArrow(FVector* LineStart, FVector* LineEnd, float ArrowSize, FColor* ArrowColor, bool bPersistentLines, float LifeTime, char DepthPriority) { NativeCall<void, FVector*, FVector*, float, FColor*, bool, float, char>(this, "AActor.Net_DrawDebugDirectionalArrow", LineStart, LineEnd, ArrowSize, ArrowColor, bPersistentLines, LifeTime, DepthPriority); }

    void Net_DrawDebugLine(FVector* LineStart, FVector* LineEnd, FColor* LineColor, bool bPersistentLines, float LifeTime, char DepthPriority, float Thickness) { NativeCall<void, FVector*, FVector*, FColor*, bool, float, char, float>(this, "AActor.Net_DrawDebugLine", LineStart, LineEnd, LineColor, bPersistentLines, LifeTime, DepthPriority, Thickness); }

    void Net_DrawDebugSphere(FVector* Center, float Radius, int Segments, FColor* SphereColor, bool bPersistentLines, float LifeTime, char DepthPriority) { NativeCall<void, FVector*, float, int, FColor*, bool, float, char>(this, "AActor.Net_DrawDebugSphere", Center, Radius, Segments, SphereColor, bPersistentLines, LifeTime, DepthPriority); }

    void OnRep_AttachmentReplication() { NativeCall<void>(this, "AActor.OnRep_AttachmentReplication"); }

    void OnRep_ReplicatedMovement() { NativeCall<void>(this, "AActor.OnRep_ReplicatedMovement"); }

    void OnSubobjectCreatedFromReplication(UObject* NewSubobject) { NativeCall<void, UObject*>(this, "AActor.OnSubobjectCreatedFromReplication", NewSubobject); }

    void OnSubobjectDestroyFromReplication(UObject* NewSubobject) { NativeCall<void, UObject*>(this, "AActor.OnSubobjectDestroyFromReplication", NewSubobject); }

    void PlaySoundAtLocation(USoundCue* InSoundCue, FVector SoundLocation, float VolumeMultiplier, float PitchMultiplier) { NativeCall<void, USoundCue*, FVector, float, float>(this, "AActor.PlaySoundAtLocation", InSoundCue, SoundLocation, VolumeMultiplier, PitchMultiplier); }

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

    void PostActorConstruction() { NativeCall<void>(this, "AActor.PostActorConstruction"); }

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

    void PostInitializeComponents() { NativeCall<void>(this, "AActor.PostInitializeComponents"); }

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

    void PostLoadSubobjects(FObjectInstancingGraph* OuterInstanceGraph) { NativeCall<void, FObjectInstancingGraph*>(this, "AActor.PostLoadSubobjects", OuterInstanceGraph); }

    void PostNetInit() { NativeCall<void>(this, "AActor.PostNetInit"); }

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

    void PostNetReceiveLocationAndRotation() { NativeCall<void>(this, "AActor.PostNetReceiveLocationAndRotation"); }

    void PostNetReceivePhysicState() { NativeCall<void>(this, "AActor.PostNetReceivePhysicState"); }

    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 PreInitializeComponents() { NativeCall<void>(this, "AActor.PreInitializeComponents"); }

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

    void PrestreamTextures(float Seconds, bool bEnableStreaming, int CinematicTextureGroups) { NativeCall<void, float, bool, int>(this, "AActor.PrestreamTextures", Seconds, bEnableStreaming, CinematicTextureGroups); }

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

    void ProcessEvent(UFunction* Function, void* Parameters) { NativeCall<void, UFunction*, void*>(this, "AActor.ProcessEvent", Function, Parameters); }

    void PropertyServerToClientsUnreliable_Implementation(AActor* ActorToRep, FName PropertyName, TArray<unsigned char>* ReplicationData) { NativeCall<void, AActor*, FName, TArray<unsigned char>*>(this, "AActor.PropertyServerToClientsUnreliable_Implementation", ActorToRep, PropertyName, ReplicationData); }

    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); }

    void REP_ActivateManualDirtyForPlayer(FName* PropertyName, APlayerController* PC) { NativeCall<void, FName*, APlayerController*>(this, "AActor.REP_ActivateManualDirtyForPlayer", PropertyName, PC); }

    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 RegisterAllComponents() { NativeCall<void>(this, "AActor.RegisterAllComponents"); }

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

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

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

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

    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); }

    void ReregisterAllComponents() { NativeCall<void>(this, "AActor.ReregisterAllComponents"); }

    void RerunConstructionScripts() { NativeCall<void>(this, "AActor.RerunConstructionScripts"); }

    void ResetOwnedComponents() { NativeCall<void>(this, "AActor.ResetOwnedComponents"); }

    void ResetPropertiesForConstruction() { NativeCall<void>(this, "AActor.ResetPropertiesForConstruction"); }

    void ResetSpatialComponent() { NativeCall<void>(this, "AActor.ResetSpatialComponent"); }

    void RouteEndPlay(EEndPlayReason::Type EndPlayReason) { NativeCall<void, EEndPlayReason::Type>(this, "AActor.RouteEndPlay", EndPlayReason); }

    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); }

    void SetActorEnableCollision(bool bNewActorEnableCollision, bool bCheckRecreatePhysicsState) { NativeCall<void, bool, bool>(this, "AActor.SetActorEnableCollision", bNewActorEnableCollision, bCheckRecreatePhysicsState); }

    void SetActorHiddenInGame(bool bNewHidden) { NativeCall<void, bool>(this, "AActor.SetActorHiddenInGame", bNewHidden); }

    bool SetActorLocation(FVector* NewLocation, bool bSweep) { return NativeCall<bool, FVector*, bool>(this, "AActor.SetActorLocation", NewLocation, bSweep); }

    bool SetActorLocationAndRotation(FVector* NewLocation, FRotator NewRotation, bool bSweep) { return NativeCall<bool, FVector*, FRotator, bool>(this, "AActor.SetActorLocationAndRotation", NewLocation, NewRotation, bSweep); }

    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 SetActorRelativeTransform(FTransform* NewRelativeTransform, bool bSweep) { NativeCall<void, FTransform*, bool>(this, "AActor.SetActorRelativeTransform", NewRelativeTransform, bSweep); }

    bool SetActorRotation(FQuat* NewRotation) { return NativeCall<bool, FQuat*>(this, "AActor.SetActorRotation", NewRotation); }

    bool SetActorRotation(FRotator NewRotation) { return NativeCall<bool, FRotator>(this, "AActor.SetActorRotation", NewRotation); }

    void SetActorScale3D(FVector* NewScale3D) { NativeCall<void, FVector*>(this, "AActor.SetActorScale3D", NewScale3D); }

    void SetActorTickEnabled(bool bEnabled) { NativeCall<void, bool>(this, "AActor.SetActorTickEnabled", bEnabled); }

    bool SetActorTransform(FTransform* NewTransform, bool bSweep) { return NativeCall<bool, FTransform*, bool>(this, "AActor.SetActorTransform", NewTransform, bSweep); }

    void SetAutonomousProxy(bool bInAutonomousProxy) { NativeCall<void, bool>(this, "AActor.SetAutonomousProxy", bInAutonomousProxy); }

    void SetLifeSpan(float InLifespan) { NativeCall<void, float>(this, "AActor.SetLifeSpan", InLifespan); }

    void SetNetUpdateTime(long double NewUpdateTime) { NativeCall<void, long double>(this, "AActor.SetNetUpdateTime", NewUpdateTime); }

    void SetNetworkSpatializationParent(AActor* NewParent) { NativeCall<void, AActor*>(this, "AActor.SetNetworkSpatializationParent", NewParent); }

    void SetOwner(AActor* NewOwner) { NativeCall<void, AActor*>(this, "AActor.SetOwner", NewOwner); }

    void SetReplicates(bool bInReplicates) { NativeCall<void, bool>(this, "AActor.SetReplicates", bInReplicates); }

    bool SetRootComponent(USceneComponent* NewRootComponent) { return NativeCall<bool, USceneComponent*>(this, "AActor.SetRootComponent", NewRootComponent); }

    void SetTickFunctionEnabled(bool bEnableTick) { NativeCall<void, bool>(this, "AActor.SetTickFunctionEnabled", bEnableTick); }

    void SetTickableWhenPaused(bool bTickableWhenPaused) { NativeCall<void, bool>(this, "AActor.SetTickableWhenPaused", bTickableWhenPaused); }

    bool SimpleTeleportTo(FVector* DestLocation, FRotator* DestRotation) { return NativeCall<bool, FVector*, FRotator*>(this, "AActor.SimpleTeleportTo", DestLocation, DestRotation); }

    void SnapRootComponentTo(AActor* InParentActor, FName InSocketName) { NativeCall<void, AActor*, FName>(this, "AActor.SnapRootComponentTo", InParentActor, InSocketName); }

    void Stasis() { NativeCall<void>(this, "AActor.Stasis"); }

    void StopActorSound(USoundBase* SoundAsset, float FadeOutTime) { NativeCall<void, USoundBase*, float>(this, "AActor.StopActorSound", SoundAsset, FadeOutTime); }

    float TakeDamage(float DamageAmount, FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { return NativeCall<float, float, FDamageEvent*, AController*, AActor*>(this, "AActor.TakeDamage", DamageAmount, DamageEvent, EventInstigator, DamageCauser); }

    bool TeleportTo(FVector* DestLocation, FRotator* DestRotation, bool bIsATest, bool bNoCheck) { return NativeCall<bool, FVector*, FRotator*, bool, bool>(this, "AActor.TeleportTo", DestLocation, DestRotation, bIsATest, bNoCheck); }

    void Tick(float DeltaSeconds) { NativeCall<void, float>(this, "AActor.Tick", DeltaSeconds); }

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

    void UninitializeComponents(EEndPlayReason::Type EndPlayReason) { NativeCall<void, EEndPlayReason::Type>(this, "AActor.UninitializeComponents", EndPlayReason); }

    void UnregisterAllComponents(bool bDetachFromOtherParent) { NativeCall<void, bool>(this, "AActor.UnregisterAllComponents", bDetachFromOtherParent); }

    void Unstasis() { NativeCall<void>(this, "AActor.Unstasis"); }

    void UpdateOverlaps(bool bDoNotifies) { NativeCall<void, bool>(this, "AActor.UpdateOverlaps", bDoNotifies); }

    void GatherCurrentMovement() { NativeCall<void>(this, "AActor.GatherCurrentMovement"); }

    AActor* GetOwner() { return NativeCall<AActor*>(this, "AActor.GetOwner"); }

    void ForceNetUpdate(bool bDormantDontReplicateProperties, bool bAbsoluteForceNetUpdate, bool bDontUpdateChannel) { NativeCall<void, bool, bool, bool>(this, "AActor.ForceNetUpdate", bDormantDontReplicateProperties, bAbsoluteForceNetUpdate, bDontUpdateChannel); }

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

    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); }

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

    void BPChangedActorTeam() { NativeCall<void>(this, "AActor.BPChangedActorTeam"); }

    void BPClientDoMultiUse(APlayerController* ForPC, int ClientUseIndex) { NativeCall<void, APlayerController*, int>(this, "AActor.BPClientDoMultiUse", ForPC, ClientUseIndex); }

    void BPClientIsAboutToSeamlessTravel() { NativeCall<void>(this, "AActor.BPClientIsAboutToSeamlessTravel"); }

    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); }

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

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

    FString* BPOverrideMultiUseCenterText(FString* result, APlayerController* ForPC) { return NativeCall<FString*, FString*, APlayerController*>(this, "AActor.BPOverrideMultiUseCenterText", result, ForPC); }

    float BPOverrideServerMultiUseAcceptRange() { return NativeCall<float>(this, "AActor.BPOverrideServerMultiUseAcceptRange"); }

    void BPPostInitializeComponents() { NativeCall<void>(this, "AActor.BPPostInitializeComponents"); }

    void BPPostLoadedFromSeamlessTravel() { NativeCall<void>(this, "AActor.BPPostLoadedFromSeamlessTravel"); }

    void BPPreInitializeComponents() { NativeCall<void>(this, "AActor.BPPreInitializeComponents"); }

    bool BPTryMultiUse(APlayerController* ForPC, int UseIndex) { return NativeCall<bool, APlayerController*, int>(this, "AActor.BPTryMultiUse", ForPC, UseIndex); }

    void ClientPrepareForSeamlessTravel() { NativeCall<void>(this, "AActor.ClientPrepareForSeamlessTravel"); }

    void ClientSeamlessTravelled() { NativeCall<void>(this, "AActor.ClientSeamlessTravelled"); }

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

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

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

    FString* GetEditTextString(FString* result, APlayerController* ForPC, UObject* AssociatedObject1, int ExtraID1, int ExtraID2) { return NativeCall<FString*, FString*, APlayerController*, UObject*, int, int>(this, "AActor.GetEditTextString", result, ForPC, AssociatedObject1, ExtraID1, ExtraID2); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "AActor.GetPrivateStaticClass", Package); }

    void InitializedSeamlessGridInfo() { NativeCall<void>(this, "AActor.InitializedSeamlessGridInfo"); }

    bool IsValidLockOnTarget(APawn* AttackerPawn) { return NativeCall<bool, APawn*>(this, "AActor.IsValidLockOnTarget", AttackerPawn); }

    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 Multi_DrawDebugCoordinateSystem(FVector AxisLoc, FRotator AxisRot, float Scale, bool bPersistentLines, float LifeTime, char DepthPriority, float Thickness) { NativeCall<void, FVector, FRotator, float, bool, float, char, float>(this, "AActor.Multi_DrawDebugCoordinateSystem", AxisLoc, AxisRot, Scale, bPersistentLines, LifeTime, DepthPriority, Thickness); }

    void Multi_DrawDebugDirectionalArrow(FVector LineStart, FVector LineEnd, float ArrowSize, FColor ArrowColor, bool bPersistentLines, float LifeTime, char DepthPriority) { NativeCall<void, FVector, FVector, float, FColor, bool, float, char>(this, "AActor.Multi_DrawDebugDirectionalArrow", LineStart, LineEnd, ArrowSize, ArrowColor, bPersistentLines, LifeTime, DepthPriority); }

    void Multi_DrawDebugLine(FVector LineStart, FVector LineEnd, FColor LineColor, bool bPersistentLines, float LifeTime, char DepthPriority, float Thickness) { NativeCall<void, FVector, FVector, FColor, bool, float, char, float>(this, "AActor.Multi_DrawDebugLine", LineStart, LineEnd, LineColor, bPersistentLines, LifeTime, DepthPriority, Thickness); }

    void Multi_DrawDebugSphere(FVector Center, float Radius, int Segments, FColor SphereColor, bool bPersistentLines, float LifeTime, char DepthPriority) { NativeCall<void, FVector, float, int, FColor, bool, float, char>(this, "AActor.Multi_DrawDebugSphere", Center, Radius, Segments, SphereColor, bPersistentLines, LifeTime, DepthPriority); }

    void NetActorSpawnActor(TSubclassOf<AActor> ActorClass, FVector AtLoc, FRotator AtRot, bool bIgnoreOnDedicatedServer, USceneComponent* AttachToComponent, FName BoneName, AActor* SpawnOwner) { NativeCall<void, TSubclassOf<AActor>, FVector, FRotator, bool, USceneComponent*, FName, AActor*>(this, "AActor.NetActorSpawnActor", ActorClass, AtLoc, AtRot, bIgnoreOnDedicatedServer, AttachToComponent, BoneName, SpawnOwner); }

    void NetAttachRootComponentTo(USceneComponent* InParent, FName InSocketName, FVector RelativeLocation, FRotator RelativeRotation) { NativeCall<void, USceneComponent*, FName, FVector, FRotator>(this, "AActor.NetAttachRootComponentTo", InParent, InSocketName, RelativeLocation, RelativeRotation); }

    void NetSpawnedActor(AActor* SpawnedActor) { NativeCall<void, AActor*>(this, "AActor.NetSpawnedActor", SpawnedActor); }

    float OffsetHUDFromBottomScreenY(AHUD* ForHUD) { return NativeCall<float, AHUD*>(this, "AActor.OffsetHUDFromBottomScreenY", ForHUD); }

    float OffsetHUDFromCenterScreenY(AHUD* ForHUD) { return NativeCall<float, AHUD*>(this, "AActor.OffsetHUDFromCenterScreenY", ForHUD); }

    void PrepareClientMapActorForSeamlessTravel() { NativeCall<void>(this, "AActor.PrepareClientMapActorForSeamlessTravel"); }

    void PropertyServerToClients(AActor* ActorToRep, FName PropertyName, TArray<unsigned char>* ReplicationData) { NativeCall<void, AActor*, FName, TArray<unsigned char>*>(this, "AActor.PropertyServerToClients", ActorToRep, PropertyName, ReplicationData); }

    void PropertyServerToClientsUnreliable(AActor* ActorToRep, FName PropertyName, TArray<unsigned char>* ReplicationData) { NativeCall<void, AActor*, FName, TArray<unsigned char>*>(this, "AActor.PropertyServerToClientsUnreliable", 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 ServerPrepareForSeamlessTravel() { NativeCall<void>(this, "AActor.ServerPrepareForSeamlessTravel"); }

    static void StaticRegisterNativesAActor() { NativeCall<void>(nullptr, "AActor.StaticRegisterNativesAActor"); }

    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"); }

    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 AddControllerPitchInput(float Val) { NativeCall<void, float>(this, "APawn.AddControllerPitchInput", Val); }

    void AddControllerRollInput(float Val) { NativeCall<void, float>(this, "APawn.AddControllerRollInput", Val); }

    void AddControllerYawInput(float Val) { NativeCall<void, float>(this, "APawn.AddControllerYawInput", Val); }

    void AddMovementInput(FVector WorldDirection, float ScaleValue, bool bForce) { NativeCall<void, FVector, float, bool>(this, "APawn.AddMovementInput", WorldDirection, ScaleValue, bForce); }

    void BecomeViewTarget(APlayerController* PC) { NativeCall<void, APlayerController*>(this, "APawn.BecomeViewTarget", PC); }

    void ClientSetRotation(FRotator NewRotation) { NativeCall<void, FRotator>(this, "APawn.ClientSetRotation", NewRotation); }

    FVector* ConsumeMovementInputVector(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APawn.ConsumeMovementInputVector", result); }

    void DestroyPlayerInputComponent() { NativeCall<void>(this, "APawn.DestroyPlayerInputComponent"); }

    void Destroyed() { NativeCall<void>(this, "APawn.Destroyed"); }

    void DetachFromControllerPendingDestroy() { NativeCall<void>(this, "APawn.DetachFromControllerPendingDestroy"); }

    void DisableInput(APlayerController* PlayerController) { NativeCall<void, APlayerController*>(this, "APawn.DisableInput", PlayerController); }

    void EnableInput(APlayerController* PlayerController) { NativeCall<void, APlayerController*>(this, "APawn.EnableInput", PlayerController); }

    void FaceRotation(FRotator NewControlRotation, float DeltaTime, bool bFromController) { NativeCall<void, FRotator, float, bool>(this, "APawn.FaceRotation", NewControlRotation, DeltaTime, bFromController); }

    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); }

    FRotator* GetControlRotation(FRotator* result) { return NativeCall<FRotator*, FRotator*>(this, "APawn.GetControlRotation", result); }

    AController* GetDamageInstigator(AController* InstigatedBy, UDamageType* DamageType) { return NativeCall<AController*, AController*, UDamageType*>(this, "APawn.GetDamageInstigator", InstigatedBy, DamageType); }

    float GetDefaultHalfHeight() { return NativeCall<float>(this, "APawn.GetDefaultHalfHeight"); }

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

    FVector* GetLastMovementInputVector(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APawn.GetLastMovementInputVector", result); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "APawn.GetLifetimeReplicatedProps", OutLifetimeProps); }

    static AActor* GetMovementBaseActor(APawn* Pawn) { return NativeCall<AActor*, APawn*>(nullptr, "APawn.GetMovementBaseActor", Pawn); }

    UNetConnection* GetNetConnection() { return NativeCall<UNetConnection*>(this, "APawn.GetNetConnection"); }

    UPlayer* GetNetOwningPlayer() { return NativeCall<UPlayer*>(this, "APawn.GetNetOwningPlayer"); }

    float GetNetPriority(FVector* ViewPos, FVector* ViewDir, APlayerController* Viewer, UActorChannel* InChannel, float Time, bool bLowBandwidth) { return NativeCall<float, FVector*, FVector*, APlayerController*, UActorChannel*, float, bool>(this, "APawn.GetNetPriority", ViewPos, ViewDir, Viewer, InChannel, Time, bLowBandwidth); }

    APlayerController* GetOwnerController() { return NativeCall<APlayerController*>(this, "APawn.GetOwnerController"); }

    FVector* GetPawnViewLocation(FVector* result, bool bAllTransforms) { return NativeCall<FVector*, FVector*, bool>(this, "APawn.GetPawnViewLocation", result, bAllTransforms); }

    FVector* GetVelocity(FVector* result, bool bIsForRagdoll) { return NativeCall<FVector*, FVector*, bool>(this, "APawn.GetVelocity", result, bIsForRagdoll); }

    FRotator* GetViewRotation(FRotator* result) { return NativeCall<FRotator*, FRotator*>(this, "APawn.GetViewRotation", result); }

    bool InFreeCam() { return NativeCall<bool>(this, "APawn.InFreeCam"); }

    void Internal_AddMovementInput(FVector WorldAccel, bool bForce) { NativeCall<void, FVector, bool>(this, "APawn.Internal_AddMovementInput", WorldAccel, bForce); }

    FVector* Internal_ConsumeMovementInputVector(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APawn.Internal_ConsumeMovementInputVector", result); }

    bool IsBasedOnActor(AActor* Other) { return NativeCall<bool, AActor*>(this, "APawn.IsBasedOnActor", Other); }

    bool IsControlled() { return NativeCall<bool>(this, "APawn.IsControlled"); }

    bool IsCrouched() { return NativeCall<bool>(this, "APawn.IsCrouched"); }

    bool IsFalling() { return NativeCall<bool>(this, "APawn.IsFalling"); }

    bool IsLocallyControlled() { return NativeCall<bool>(this, "APawn.IsLocallyControlled"); }

    bool IsLocallyControlledByPlayer() { return NativeCall<bool>(this, "APawn.IsLocallyControlledByPlayer"); }

    bool IsMoveInputIgnored() { return NativeCall<bool>(this, "APawn.IsMoveInputIgnored"); }

    bool IsNetRelevantFor(APlayerController* RealViewer, AActor* Viewer, FVector* SrcLocation) { return NativeCall<bool, APlayerController*, AActor*, FVector*>(this, "APawn.IsNetRelevantFor", RealViewer, Viewer, SrcLocation); }

    bool IsWalking() { return NativeCall<bool>(this, "APawn.IsWalking"); }

    FVector* K2_GetMovementInputVector(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APawn.K2_GetMovementInputVector", result); }

    void LaunchPawn(FVector LaunchVelocity, bool bXYOverride, bool bZOverride) { NativeCall<void, FVector, bool, bool>(this, "APawn.LaunchPawn", LaunchVelocity, bXYOverride, bZOverride); }

    void MoveIgnoreActorAdd(AActor* ActorToIgnore) { NativeCall<void, AActor*>(this, "APawn.MoveIgnoreActorAdd", ActorToIgnore); }

    void OnRep_Controller() { NativeCall<void>(this, "APawn.OnRep_Controller"); }

    void OutsideWorldBounds() { NativeCall<void>(this, "APawn.OutsideWorldBounds"); }

    void PawnClientRestart() { NativeCall<void>(this, "APawn.PawnClientRestart"); }

    void PawnMakeNoise(float Loudness, FVector NoiseLocation, bool bUseNoiseMakerLocation, AActor* NoiseMaker) { NativeCall<void, float, FVector, bool, AActor*>(this, "APawn.PawnMakeNoise", Loudness, NoiseLocation, bUseNoiseMakerLocation, NoiseMaker); }

    void PossessedBy(AController* NewController) { NativeCall<void, AController*>(this, "APawn.PossessedBy", NewController); }

    void PostInitializeComponents() { NativeCall<void>(this, "APawn.PostInitializeComponents"); }

    void PostInputProcessed() { NativeCall<void>(this, "APawn.PostInputProcessed"); }

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

    void PostNetReceiveLocationAndRotation() { NativeCall<void>(this, "APawn.PostNetReceiveLocationAndRotation"); }

    void PostNetReceiveVelocity(FVector* NewVelocity) { NativeCall<void, FVector*>(this, "APawn.PostNetReceiveVelocity", NewVelocity); }

    void PostRegisterAllComponents() { NativeCall<void>(this, "APawn.PostRegisterAllComponents"); }

    void PreInitializeComponents() { NativeCall<void>(this, "APawn.PreInitializeComponents"); }

    bool ReachedDesiredRotation() { return NativeCall<bool>(this, "APawn.ReachedDesiredRotation"); }

    void RecalculateBaseEyeHeight() { NativeCall<void>(this, "APawn.RecalculateBaseEyeHeight"); }

    void Reset() { NativeCall<void>(this, "APawn.Reset"); }

    void Restart() { NativeCall<void>(this, "APawn.Restart"); }

    void SetCanAffectNavigationGeneration(bool bNewValue) { NativeCall<void, bool>(this, "APawn.SetCanAffectNavigationGeneration", bNewValue); }

    bool ShouldTakeDamage(float Damage, FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { return NativeCall<bool, float, FDamageEvent*, AController*, AActor*>(this, "APawn.ShouldTakeDamage", Damage, DamageEvent, EventInstigator, DamageCauser); }

    bool ShouldTickIfViewportsOnly() { return NativeCall<bool>(this, "APawn.ShouldTickIfViewportsOnly"); }

    void SpawnDefaultController() { NativeCall<void>(this, "APawn.SpawnDefaultController"); }

    float TakeDamage(float Damage, FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { return NativeCall<float, float, FDamageEvent*, AController*, AActor*>(this, "APawn.TakeDamage", Damage, DamageEvent, EventInstigator, DamageCauser); }

    void Tick(float DeltaSeconds) { NativeCall<void, float>(this, "APawn.Tick", DeltaSeconds); }

    void TickBasedCharacters(float DeltaSeconds) { NativeCall<void, float>(this, "APawn.TickBasedCharacters", DeltaSeconds); }

    void TurnOff() { NativeCall<void>(this, "APawn.TurnOff"); }

    void UnPossessed() { NativeCall<void>(this, "APawn.UnPossessed"); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "APawn.GetPrivateStaticClass", Package); }

    void ReceivePossessed(AController* NewController) { NativeCall<void, AController*>(this, "APawn.ReceivePossessed", NewController); }

    void ReceiveUnpossessed(AController* OldController) { NativeCall<void, AController*>(this, "APawn.ReceiveUnpossessed", OldController); }

    static void StaticRegisterNativesAPawn() { NativeCall<void>(nullptr, "APawn.StaticRegisterNativesAPawn"); }

};


struct UCheatManager

{

    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 BugIt(FString* ScreenShotDescription) { NativeCall<void, FString*>(this, "UCheatManager.BugIt", ScreenShotDescription); }

    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 BugItStringCreator(FVector ViewLocation, FRotator ViewRotation, FString* GoString, FString* LocString) { NativeCall<void, FVector, FRotator, FString*, FString*>(this, "UCheatManager.BugItStringCreator", ViewLocation, ViewRotation, GoString, LocString); }

    void BugItWorker(FVector TheLocation, FRotator TheRotation) { NativeCall<void, FVector, FRotator>(this, "UCheatManager.BugItWorker", TheLocation, TheRotation); }

    void ChangeSize(float F) { NativeCall<void, float>(this, "UCheatManager.ChangeSize", F); }

    void DamageTarget(float DamageAmount) { NativeCall<void, float>(this, "UCheatManager.DamageTarget", DamageAmount); }

    void DebugCapsuleSweep() { NativeCall<void>(this, "UCheatManager.DebugCapsuleSweep"); }

    void DebugCapsuleSweepCapture() { NativeCall<void>(this, "UCheatManager.DebugCapsuleSweepCapture"); }

    void DebugCapsuleSweepChannel(ECollisionChannel Channel) { NativeCall<void, ECollisionChannel>(this, "UCheatManager.DebugCapsuleSweepChannel", Channel); }

    void DebugCapsuleSweepClear() { NativeCall<void>(this, "UCheatManager.DebugCapsuleSweepClear"); }

    void DebugCapsuleSweepComplex(bool bTraceComplex) { NativeCall<void, bool>(this, "UCheatManager.DebugCapsuleSweepComplex", bTraceComplex); }

    void DebugCapsuleSweepPawn() { NativeCall<void>(this, "UCheatManager.DebugCapsuleSweepPawn"); }

    void DebugCapsuleSweepSize(float HalfHeight, float Radius) { NativeCall<void, float, float>(this, "UCheatManager.DebugCapsuleSweepSize", HalfHeight, Radius); }

    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 DestroyTarget() { NativeCall<void>(this, "UCheatManager.DestroyTarget"); }

    void DisableDebugCamera() { NativeCall<void>(this, "UCheatManager.DisableDebugCamera"); }

    void DumpOnlineSessionState() { NativeCall<void>(this, "UCheatManager.DumpOnlineSessionState"); }

    void DumpVoiceMutingState() { NativeCall<void>(this, "UCheatManager.DumpVoiceMutingState"); }

    void EnableDebugCamera() { NativeCall<void>(this, "UCheatManager.EnableDebugCamera"); }

    void FlushLog() { NativeCall<void>(this, "UCheatManager.FlushLog"); }

    void Fly() { NativeCall<void>(this, "UCheatManager.Fly"); }

    void FreezeFrame(float delay) { NativeCall<void, float>(this, "UCheatManager.FreezeFrame", delay); }

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

    void Ghost() { NativeCall<void>(this, "UCheatManager.Ghost"); }

    void God() { NativeCall<void>(this, "UCheatManager.God"); }

    void LogLoc() { NativeCall<void>(this, "UCheatManager.LogLoc"); }

    void OnlyLoadLevel(FName PackageName) { NativeCall<void, FName>(this, "UCheatManager.OnlyLoadLevel", PackageName); }

    void PlayersOnly() { NativeCall<void>(this, "UCheatManager.PlayersOnly"); }

    void RebuildNavigation() { NativeCall<void>(this, "UCheatManager.RebuildNavigation"); }

    void SetLevelStreamingStatus(FName PackageName, bool bShouldBeLoaded, bool bShouldBeVisible) { NativeCall<void, FName, bool, bool>(this, "UCheatManager.SetLevelStreamingStatus", PackageName, bShouldBeLoaded, bShouldBeVisible); }

    void SetNavDrawDistance(float DrawDistance) { NativeCall<void, float>(this, "UCheatManager.SetNavDrawDistance", DrawDistance); }

    void SetWorldOrigin() { NativeCall<void>(this, "UCheatManager.SetWorldOrigin"); }

    void Slomo(float T) { NativeCall<void, float>(this, "UCheatManager.Slomo", T); }

    void StreamLevelIn(FName PackageName) { NativeCall<void, FName>(this, "UCheatManager.StreamLevelIn", PackageName); }

    void StreamLevelOut(FName PackageName) { NativeCall<void, FName>(this, "UCheatManager.StreamLevelOut", PackageName); }

    void Summon(FString* ClassName) { NativeCall<void, FString*>(this, "UCheatManager.Summon", ClassName); }

    void Teleport() { NativeCall<void>(this, "UCheatManager.Teleport"); }

    void TestCollisionDistance() { NativeCall<void>(this, "UCheatManager.TestCollisionDistance"); }

    void ToggleDebugCamera() { NativeCall<void>(this, "UCheatManager.ToggleDebugCamera"); }

    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 ViewPlayer(FString* S) { NativeCall<void, FString*>(this, "UCheatManager.ViewPlayer", S); }

    void ViewSelf() { NativeCall<void>(this, "UCheatManager.ViewSelf"); }

    void Walk() { NativeCall<void>(this, "UCheatManager.Walk"); }

    void WidgetReflector() { NativeCall<void>(this, "UCheatManager.WidgetReflector"); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "UCheatManager.GetPrivateStaticClass", Package); }

    void ServerToggleAILogging() { NativeCall<void>(this, "UCheatManager.ServerToggleAILogging"); }

    static void StaticRegisterNativesUCheatManager() { NativeCall<void>(nullptr, "UCheatManager.StaticRegisterNativesUCheatManager"); }

};


struct UShooterCheatManager : UCheatManager

{

    bool& bIsRCONCheatManagerField() { return *GetNativePointerField<bool*>(this, "UShooterCheatManager.bIsRCONCheatManager"); }

    AShooterPlayerController* MyPCField() { return *GetNativePointerField<AShooterPlayerController**>(this, "UShooterCheatManager.MyPC"); }


    // Functions


    void AddExperience(float HowMuch, bool fromTribeShare, bool bPreventSharingWithTribe) { NativeCall<void, float, bool, bool>(this, "UShooterCheatManager.AddExperience", HowMuch, fromTribeShare, bPreventSharingWithTribe); }

    void AddShipExperience(float HowMuch) { NativeCall<void, float>(this, "UShooterCheatManager.AddShipExperience", HowMuch); }

    void AllowPlayerToJoinNoCheck(FString* SteamId) { NativeCall<void, FString*>(this, "UShooterCheatManager.AllowPlayerToJoinNoCheck", SteamId); }

    void BanPlayer(FString PlayerSteamName) { NativeCall<void, FString>(this, "UShooterCheatManager.BanPlayer", PlayerSteamName); }

    void BritishEmpire() { NativeCall<void>(this, "UShooterCheatManager.BritishEmpire"); }

    void Broadcast(FString* MessageText) { NativeCall<void, FString*>(this, "UShooterCheatManager.Broadcast", MessageText); }

    void CamZoomIn() { NativeCall<void>(this, "UShooterCheatManager.CamZoomIn"); }

    void CamZoomOut() { NativeCall<void>(this, "UShooterCheatManager.CamZoomOut"); }

    void ClearAllClaimFlagData() { NativeCall<void>(this, "UShooterCheatManager.ClearAllClaimFlagData"); }

    void ClearPlayerInventory(int playerID, bool bClearInventory, bool bClearSlotItems, bool bClearEquippedItems) { NativeCall<void, int, bool, bool, bool>(this, "UShooterCheatManager.ClearPlayerInventory", playerID, bClearInventory, bClearSlotItems, bClearEquippedItems); }

    void ClearTutorials() { NativeCall<void>(this, "UShooterCheatManager.ClearTutorials"); }

    void ClusterStatusDump() { NativeCall<void>(this, "UShooterCheatManager.ClusterStatusDump"); }

    void CollectNearbyTreasures() { NativeCall<void>(this, "UShooterCheatManager.CollectNearbyTreasures"); }

    void CompleteQuest(int QuestID) { NativeCall<void, int>(this, "UShooterCheatManager.CompleteQuest", QuestID); }

    void DestroyActors(FString* ClassName) { NativeCall<void, FString*>(this, "UShooterCheatManager.DestroyActors", ClassName); }

    void DestroyAllEnemies() { NativeCall<void>(this, "UShooterCheatManager.DestroyAllEnemies"); }

    void DestroyAllNonSaddlePlayerStructures() { NativeCall<void>(this, "UShooterCheatManager.DestroyAllNonSaddlePlayerStructures"); }

    void DestroyAllStructure() { NativeCall<void>(this, "UShooterCheatManager.DestroyAllStructure"); }

    void DestroyAllTames() { NativeCall<void>(this, "UShooterCheatManager.DestroyAllTames"); }

    void DestroyMyTarget() { NativeCall<void>(this, "UShooterCheatManager.DestroyMyTarget"); }

    void DestroyStructures() { NativeCall<void>(this, "UShooterCheatManager.DestroyStructures"); }

    void DestroyTribeDinos() { NativeCall<void>(this, "UShooterCheatManager.DestroyTribeDinos"); }

    void DestroyTribeId(int TribeTeamID) { NativeCall<void, int>(this, "UShooterCheatManager.DestroyTribeId", TribeTeamID); }

    void DestroyTribeIdDinos(unsigned __int64 TribeTeamID) { NativeCall<void, unsigned __int64>(this, "UShooterCheatManager.DestroyTribeIdDinos", TribeTeamID); }

    void DestroyTribeIdPlayers(__int64 TribeTeamID) { NativeCall<void, __int64>(this, "UShooterCheatManager.DestroyTribeIdPlayers", TribeTeamID); }

    void DestroyTribeIdStructures(__int64 TribeTeamID) { NativeCall<void, __int64>(this, "UShooterCheatManager.DestroyTribeIdStructures", TribeTeamID); }

    void DestroyTribePlayers() { NativeCall<void>(this, "UShooterCheatManager.DestroyTribePlayers"); }

    void DestroyTribeStructures() { NativeCall<void>(this, "UShooterCheatManager.DestroyTribeStructures"); }

    void DestroyTribeStructuresLessThan(int TribeTeamID, int Connections) { NativeCall<void, int, int>(this, "UShooterCheatManager.DestroyTribeStructuresLessThan", TribeTeamID, Connections); }

    void DestroyWildDinos() { NativeCall<void>(this, "UShooterCheatManager.DestroyWildDinos"); }

    void DetachChar() { NativeCall<void>(this, "UShooterCheatManager.DetachChar"); }

    void DisableBeds(bool bDisableBedsOnServer) { NativeCall<void, bool>(this, "UShooterCheatManager.DisableBeds", bDisableBedsOnServer); }

    void DisableSpectator() { NativeCall<void>(this, "UShooterCheatManager.DisableSpectator"); }

    void DisallowPlayerToJoinNoCheck(FString* SteamId) { NativeCall<void, FString*>(this, "UShooterCheatManager.DisallowPlayerToJoinNoCheck", SteamId); }

    void DoExit() { NativeCall<void>(this, "UShooterCheatManager.DoExit"); }

    void DoLeaveTribe() { NativeCall<void>(this, "UShooterCheatManager.DoLeaveTribe"); }

    void DoRestartLevel() { NativeCall<void>(this, "UShooterCheatManager.DoRestartLevel"); }

    AActor* DoSummon(FString* ClassName) { return NativeCall<AActor*, FString*>(this, "UShooterCheatManager.DoSummon", ClassName); }

    void DoTame() { NativeCall<void>(this, "UShooterCheatManager.DoTame"); }

    void EnableCheats(FString pass) { NativeCall<void, FString>(this, "UShooterCheatManager.EnableCheats", pass); }

    void EnableSpectator() { NativeCall<void>(this, "UShooterCheatManager.EnableSpectator"); }

    void EnemyInVisible(bool Invisible) { NativeCall<void, bool>(this, "UShooterCheatManager.EnemyInVisible", Invisible); }

    AShooterPlayerController* FindPlayerControllerFromPlayerID(__int64 PlayerID) { return NativeCall<AShooterPlayerController*, __int64>(this, "UShooterCheatManager.FindPlayerControllerFromPlayerID", PlayerID); }

    void ForcePlayerToJoinTargetTribe(__int64 PlayerID) { NativeCall<void, __int64>(this, "UShooterCheatManager.ForcePlayerToJoinTargetTribe", PlayerID); }

    void ForcePlayerToJoinTribe(__int64 PlayerID, FString TribeName) { NativeCall<void, __int64, FString>(this, "UShooterCheatManager.ForcePlayerToJoinTribe", PlayerID, TribeName); }

    void ForceRenameMyTribe(FString newTribeName) { NativeCall<void, FString>(this, "UShooterCheatManager.ForceRenameMyTribe", newTribeName); }

    void ForceTame() { NativeCall<void>(this, "UShooterCheatManager.ForceTame"); }

    void ForceTravelAbort(int nForceAbort) { NativeCall<void, int>(this, "UShooterCheatManager.ForceTravelAbort", nForceAbort); }

    void ForceTribes(FString* PlayerName1, FString* PlayerName2, FString* NewTribeName) { NativeCall<void, FString*, FString*, FString*>(this, "UShooterCheatManager.ForceTribes", PlayerName1, PlayerName2, NewTribeName); }

    void GCM() { NativeCall<void>(this, "UShooterCheatManager.GCM"); }

    void GCMP(__int64 PlayerID) { NativeCall<void, __int64>(this, "UShooterCheatManager.GCMP", PlayerID); }

    void GCMT() { NativeCall<void>(this, "UShooterCheatManager.GCMT"); }

    void GFI(FName* blueprintPath, int quantityOverride, float qualityOverride, bool bForceBlueprint) { NativeCall<void, FName*, int, float, bool>(this, "UShooterCheatManager.GFI", blueprintPath, quantityOverride, qualityOverride, bForceBlueprint); }

    void GMBuff() { NativeCall<void>(this, "UShooterCheatManager.GMBuff"); }

    void GMSummon(FString* ClassName, int Level) { NativeCall<void, FString*, int>(this, "UShooterCheatManager.GMSummon", ClassName, Level); }

    void GameCommand(FString* TheCommand) { NativeCall<void, FString*>(this, "UShooterCheatManager.GameCommand", TheCommand); }

    void GenerateTribePNG(FString tribeID) { NativeCall<void, FString>(this, "UShooterCheatManager.GenerateTribePNG", tribeID); }

    void GetChat() { NativeCall<void>(this, "UShooterCheatManager.GetChat"); }

    void GetGameLog() { NativeCall<void>(this, "UShooterCheatManager.GetGameLog"); }

    void GetNumGlobalShipsForMyTribe() { NativeCall<void>(this, "UShooterCheatManager.GetNumGlobalShipsForMyTribe"); }

    void GetPlayerIDForSteamID(int SteamID) { NativeCall<void, int>(this, "UShooterCheatManager.GetPlayerIDForSteamID", SteamID); }

    void GetSteamIDForPlayerID(int PlayerID) { NativeCall<void, int>(this, "UShooterCheatManager.GetSteamIDForPlayerID", PlayerID); }

    void GetTribeIdPlayerList(int TribeID) { NativeCall<void, int>(this, "UShooterCheatManager.GetTribeIdPlayerList", TribeID); }

    void GiveAllDiscoZones() { NativeCall<void>(this, "UShooterCheatManager.GiveAllDiscoZones"); }

    void GiveAllStructure() { NativeCall<void>(this, "UShooterCheatManager.GiveAllStructure"); }

    void GiveCreativeMode() { NativeCall<void>(this, "UShooterCheatManager.GiveCreativeMode"); }

    void GiveCreativeModeToPlayer(__int64 PlayerID) { NativeCall<void, __int64>(this, "UShooterCheatManager.GiveCreativeModeToPlayer", PlayerID); }

    void GiveCreativeModeToTarget() { NativeCall<void>(this, "UShooterCheatManager.GiveCreativeModeToTarget"); }

    void GiveEngrams() { NativeCall<void>(this, "UShooterCheatManager.GiveEngrams"); }

    void GiveExpToPlayer(__int64 PlayerID, float HowMuch, bool fromTribeShare, bool bPreventSharingWithTribe) { NativeCall<void, __int64, float, bool, bool>(this, "UShooterCheatManager.GiveExpToPlayer", PlayerID, HowMuch, fromTribeShare, bPreventSharingWithTribe); }

    void GiveFOW() { NativeCall<void>(this, "UShooterCheatManager.GiveFOW"); }

    void GiveItem(FString* blueprintPath, int quantityOverride, float qualityOverride, bool bForceBlueprint) { NativeCall<void, FString*, int, float, bool>(this, "UShooterCheatManager.GiveItem", blueprintPath, quantityOverride, qualityOverride, bForceBlueprint); }

    void GiveItemNum(int masterIndexNum, int quantityOverride, float qualityOverride, bool bForceBlueprint) { NativeCall<void, int, int, float, bool>(this, "UShooterCheatManager.GiveItemNum", masterIndexNum, 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 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 GiveResources() { NativeCall<void>(this, "UShooterCheatManager.GiveResources"); }

    void GiveToMe() { NativeCall<void>(this, "UShooterCheatManager.GiveToMe"); }

    void GiveTreasureLoot(float TreasureQuality) { NativeCall<void, float>(this, "UShooterCheatManager.GiveTreasureLoot", TreasureQuality); }

    void GiveTreasureMap(float Quality) { NativeCall<void, float>(this, "UShooterCheatManager.GiveTreasureMap", Quality); }

    void GridTP(FString ServerGrid, float ServerLocalPosX, float ServerLocalPosY, float ServerLocalPosZ) { NativeCall<void, FString, float, float, float>(this, "UShooterCheatManager.GridTP", ServerGrid, ServerLocalPosX, ServerLocalPosY, ServerLocalPosZ); }

    void GridTPManual(unsigned __int16 GridX, unsigned __int16 GridY, float ServerLocalPosX, float ServerLocalPosY, float ServerLocalPosZ) { NativeCall<void, unsigned __int16, unsigned __int16, float, float, float>(this, "UShooterCheatManager.GridTPManual", GridX, GridY, ServerLocalPosX, ServerLocalPosY, ServerLocalPosZ); }

    void GridTravelToGlobalPos(float ToGlobalPosX, float ToGlobalPosY, float ToGlobalPosZ) { NativeCall<void, float, float, float>(this, "UShooterCheatManager.GridTravelToGlobalPos", ToGlobalPosX, ToGlobalPosY, ToGlobalPosZ); }

    void GridTravelToLocalPos(unsigned __int16 GridX, unsigned __int16 GridY, float ServerLocalPosX, float ServerLocalPosY, float ServerLocalPosZ) { NativeCall<void, unsigned __int16, unsigned __int16, float, float, float>(this, "UShooterCheatManager.GridTravelToLocalPos", GridX, GridY, ServerLocalPosX, ServerLocalPosY, ServerLocalPosZ); }

    void GridUTCResetTimeOfDay() { NativeCall<void>(this, "UShooterCheatManager.GridUTCResetTimeOfDay"); }

    void HiWarp(FString* ClassName, int Index) { NativeCall<void, FString*, int>(this, "UShooterCheatManager.HiWarp", ClassName, Index); }

    void HibernationReport(FString* ClassName) { NativeCall<void, FString*>(this, "UShooterCheatManager.HibernationReport", ClassName); }

    void HideTutorial(int TutorialInde) { NativeCall<void, int>(this, "UShooterCheatManager.HideTutorial", TutorialInde); }

    void InfiniteAmmo() { NativeCall<void>(this, "UShooterCheatManager.InfiniteAmmo"); }

    void InfiniteStats() { NativeCall<void>(this, "UShooterCheatManager.InfiniteStats"); }

    void KickPlayer(FString PlayerSteamName) { NativeCall<void, FString>(this, "UShooterCheatManager.KickPlayer", PlayerSteamName); }

    void Kill() { NativeCall<void>(this, "UShooterCheatManager.Kill"); }

    void KillPlayer(__int64 PlayerID) { NativeCall<void, __int64>(this, "UShooterCheatManager.KillPlayer", PlayerID); }

    void LMA() { NativeCall<void>(this, "UShooterCheatManager.LMA"); }

    void ListPlayers() { NativeCall<void>(this, "UShooterCheatManager.ListPlayers"); }

    void MakeSpooky(FString* ItemsToGive, float SpawnDist, int NumberOfSkeletons) { NativeCall<void, FString*, float, int>(this, "UShooterCheatManager.MakeSpooky", ItemsToGive, SpawnDist, NumberOfSkeletons); }

    void MakeTribeAdmin() { NativeCall<void>(this, "UShooterCheatManager.MakeTribeAdmin"); }

    void MakeTribeFounder() { NativeCall<void>(this, "UShooterCheatManager.MakeTribeFounder"); }

    void OnToggleInGameMenu() { NativeCall<void>(this, "UShooterCheatManager.OnToggleInGameMenu"); }

    void OpenMap(FString* MapName) { NativeCall<void, FString*>(this, "UShooterCheatManager.OpenMap", MapName); }

    void OutGoingTransfersEnabled(bool bEnabled) { NativeCall<void, bool>(this, "UShooterCheatManager.OutGoingTransfersEnabled", bEnabled); }

    void PlayerCommand(FString* TheCommand) { NativeCall<void, FString*>(this, "UShooterCheatManager.PlayerCommand", TheCommand); }

    void PrintActorLocation(FString* ActorName) { NativeCall<void, FString*>(this, "UShooterCheatManager.PrintActorLocation", ActorName); }

    void PrintMessageOut(FString* Msg) { NativeCall<void, FString*>(this, "UShooterCheatManager.PrintMessageOut", Msg); }

    void RefreshTerrityoryUrls() { NativeCall<void>(this, "UShooterCheatManager.RefreshTerrityoryUrls"); }

    void ReloadAdminIPs() { NativeCall<void>(this, "UShooterCheatManager.ReloadAdminIPs"); }

    void ReloadAdminSteamIDs() { NativeCall<void>(this, "UShooterCheatManager.ReloadAdminSteamIDs"); }

    void ReloadTopTribes() { NativeCall<void>(this, "UShooterCheatManager.ReloadTopTribes"); }

    void RemoveTribeAdmin() { NativeCall<void>(this, "UShooterCheatManager.RemoveTribeAdmin"); }

    void RenamePlayer(FString* PlayerName, FString* NewName) { NativeCall<void, FString*, FString*>(this, "UShooterCheatManager.RenamePlayer", PlayerName, NewName); }

    void RenameTribe(FString* TribeName, FString* NewName) { NativeCall<void, FString*, FString*>(this, "UShooterCheatManager.RenameTribe", TribeName, NewName); }

    void RepopulateServerClaimFlagData() { NativeCall<void>(this, "UShooterCheatManager.RepopulateServerClaimFlagData"); }

    void ReportLeastSpawnManagers() { NativeCall<void>(this, "UShooterCheatManager.ReportLeastSpawnManagers"); }

    void ReportSpawnManagers() { NativeCall<void>(this, "UShooterCheatManager.ReportSpawnManagers"); }

    void RotateTribeLog() { NativeCall<void>(this, "UShooterCheatManager.RotateTribeLog"); }

    void RunMoveInChractersOutOfBounds() { NativeCall<void>(this, "UShooterCheatManager.RunMoveInChractersOutOfBounds"); }

    void SDF(FName* DinoBlueprintPath, bool bIsTamed) { NativeCall<void, FName*, bool>(this, "UShooterCheatManager.SDF", DinoBlueprintPath, bIsTamed); }

    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 SSF(FString* ShipName) { NativeCall<void, FString*>(this, "UShooterCheatManager.SSF", ShipName); }

    void SaveWorld() { NativeCall<void>(this, "UShooterCheatManager.SaveWorld"); }

    void ScriptCommand(FString* commandString) { NativeCall<void, FString*>(this, "UShooterCheatManager.ScriptCommand", commandString); }

    void SeamlessSocketTickInterval(float Sec) { NativeCall<void, float>(this, "UShooterCheatManager.SeamlessSocketTickInterval", Sec); }

    void ServerChat(FString* MessageText) { NativeCall<void, FString*>(this, "UShooterCheatManager.ServerChat", MessageText); }

    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 SetAdminFastClaiming(bool bEnable) { NativeCall<void, bool>(this, "UShooterCheatManager.SetAdminFastClaiming", bEnable); }

    void SetAimMagnetism(float NewMagnetism) { NativeCall<void, float>(this, "UShooterCheatManager.SetAimMagnetism", NewMagnetism); }

    void SetBabyAge(float AgeValue) { NativeCall<void, float>(this, "UShooterCheatManager.SetBabyAge", AgeValue); }

    void SetBodyFat(float BodyFatPercent) { NativeCall<void, float>(this, "UShooterCheatManager.SetBodyFat", BodyFatPercent); }

    void SetCheatXP(bool bEnable) { NativeCall<void, bool>(this, "UShooterCheatManager.SetCheatXP", bEnable); }

    bool SetCreativeModeOnPawn(AShooterCharacter* Pawn, bool bCreativeMode) { return NativeCall<bool, AShooterCharacter*, bool>(this, "UShooterCheatManager.SetCreativeModeOnPawn", Pawn, bCreativeMode); }

    void SetDebugMelee(bool Discrete, int DebugMelee) { NativeCall<void, bool, int>(this, "UShooterCheatManager.SetDebugMelee", Discrete, DebugMelee); }

    void SetFacialHairPercent(float thePercent) { NativeCall<void, float>(this, "UShooterCheatManager.SetFacialHairPercent", thePercent); }

    void SetFacialHairstyle(int hairStyleIndex) { NativeCall<void, int>(this, "UShooterCheatManager.SetFacialHairstyle", hairStyleIndex); }

    void SetGlobalPause(bool bIsPaused) { NativeCall<void, bool>(this, "UShooterCheatManager.SetGlobalPause", bIsPaused); }

    void SetGodMode(bool bEnable) { NativeCall<void, bool>(this, "UShooterCheatManager.SetGodMode", bEnable); }

    void SetGraphicsQuality(int val) { NativeCall<void, int>(this, "UShooterCheatManager.SetGraphicsQuality", val); }

    void SetHeadHairPercent(float thePercent) { NativeCall<void, float>(this, "UShooterCheatManager.SetHeadHairPercent", thePercent); }

    void SetHeadHairstyle(int hairStyleIndex) { NativeCall<void, int>(this, "UShooterCheatManager.SetHeadHairstyle", hairStyleIndex); }

    void SetHomeServer(int PlayerID, unsigned int ServerID) { NativeCall<void, int, unsigned int>(this, "UShooterCheatManager.SetHomeServer", PlayerID, ServerID); }

    void SetIgnoreWind(bool ShouldIgnore) { NativeCall<void, bool>(this, "UShooterCheatManager.SetIgnoreWind", ShouldIgnore); }

    void SetImprintQuality(float ImprintQuality) { NativeCall<void, float>(this, "UShooterCheatManager.SetImprintQuality", ImprintQuality); }

    void SetInterpolatedLocation(bool NewValue) { NativeCall<void, bool>(this, "UShooterCheatManager.SetInterpolatedLocation", NewValue); }

    void SetMessageOfTheDay(FString* Message) { NativeCall<void, FString*>(this, "UShooterCheatManager.SetMessageOfTheDay", Message); }

    void SetMyTargetSleeping(bool bIsSleeping) { NativeCall<void, bool>(this, "UShooterCheatManager.SetMyTargetSleeping", bIsSleeping); }

    void SetMyTribeAllowRename(bool bAllow) { NativeCall<void, bool>(this, "UShooterCheatManager.SetMyTribeAllowRename", bAllow); }

    void SetPlayerNotificationBan(FString AccountID, bool Banned) { NativeCall<void, FString, bool>(this, "UShooterCheatManager.SetPlayerNotificationBan", AccountID, Banned); }

    void SetPlayerNotifications(FString AccountID, FString Email, unsigned int EmailCategoryMask, FString Webhook, unsigned int WebhookCategoryMask) { NativeCall<void, FString, FString, unsigned int, FString, unsigned int>(this, "UShooterCheatManager.SetPlayerNotifications", AccountID, Email, EmailCategoryMask, Webhook, WebhookCategoryMask); }

    void SetPlayerPos(float X, float Y, float Z) { NativeCall<void, float, float, float>(this, "UShooterCheatManager.SetPlayerPos", X, Y, Z); }

    void SetShowAllPlayers(bool bEnable) { NativeCall<void, bool>(this, "UShooterCheatManager.SetShowAllPlayers", bEnable); }

    void SetStatusValue(int StatusIndex, float StatusValue) { NativeCall<void, int, float>(this, "UShooterCheatManager.SetStatusValue", StatusIndex, StatusValue); }

    void SetStepImpulsing(bool NewImpulsing) { NativeCall<void, bool>(this, "UShooterCheatManager.SetStepImpulsing", NewImpulsing); }

    void SetTargetDinoColor(int ColorRegion, int ColorID) { NativeCall<void, int, int>(this, "UShooterCheatManager.SetTargetDinoColor", ColorRegion, ColorID); }

    void SetTargetPlayerColorVal(int ColorValIndex, float ColorVal) { NativeCall<void, int, float>(this, "UShooterCheatManager.SetTargetPlayerColorVal", ColorValIndex, ColorVal); }

    void SetTimeOfDay(FString* timeString) { NativeCall<void, FString*>(this, "UShooterCheatManager.SetTimeOfDay", timeString); }

    void SharedLogCleanup(bool bForce) { NativeCall<void, bool>(this, "UShooterCheatManager.SharedLogCleanup", bForce); }

    void SharedLogFetch() { NativeCall<void>(this, "UShooterCheatManager.SharedLogFetch"); }

    void SharedLogReportLine() { NativeCall<void>(this, "UShooterCheatManager.SharedLogReportLine"); }

    void SharedLogSnapshot() { NativeCall<void>(this, "UShooterCheatManager.SharedLogSnapshot"); }

    void SharedLogSnapshotAndUpload() { NativeCall<void>(this, "UShooterCheatManager.SharedLogSnapshotAndUpload"); }

    void ShowInGameMenu() { NativeCall<void>(this, "UShooterCheatManager.ShowInGameMenu"); }

    void ShowMessageOfTheDay() { NativeCall<void>(this, "UShooterCheatManager.ShowMessageOfTheDay"); }

    void ShowTutorial(int TutorialIndex, bool bForceDisplay) { NativeCall<void, int, bool>(this, "UShooterCheatManager.ShowTutorial", TutorialIndex, bForceDisplay); }

    void SpawnActor(FString* blueprintPath, float spawnDistance, float spawnYOffset, float ZOffset) { NativeCall<void, FString*, float, float, float>(this, "UShooterCheatManager.SpawnActor", blueprintPath, spawnDistance, spawnYOffset, ZOffset); }

    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 SpawnActorTamed(FString* blueprintPath, float spawnDistance, float spawnYOffset, float ZOffset) { NativeCall<void, FString*, float, float, float>(this, "UShooterCheatManager.SpawnActorTamed", blueprintPath, spawnDistance, spawnYOffset, ZOffset); }

    void SpawnBrig() { NativeCall<void>(this, "UShooterCheatManager.SpawnBrig"); }

    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); }

    void SpawnFleet(int SpawnCount) { NativeCall<void, int>(this, "UShooterCheatManager.SpawnFleet", SpawnCount); }

    void SpawnFleetEx(FString* ShipName, int SpawnCount, bool bAddDecks, bool bAddSails) { NativeCall<void, FString*, int, bool, bool>(this, "UShooterCheatManager.SpawnFleetEx", ShipName, SpawnCount, bAddDecks, bAddSails); }

    void SpawnPathFollowingShip(FString PathName) { NativeCall<void, FString>(this, "UShooterCheatManager.SpawnPathFollowingShip", PathName); }

    void SpawnShip(FString* blueprintPathShip, FString* blueprintPathHull, float spawnDist, bool bAddDecks, bool bAddSails, bool bAutoPilotShip) { NativeCall<void, FString*, FString*, float, bool, bool, bool>(this, "UShooterCheatManager.SpawnShip", blueprintPathShip, blueprintPathHull, spawnDist, bAddDecks, bAddSails, bAutoPilotShip); }

    void SpawnShipFast(FString* ShipName, float SpawnDist, bool bAddDecks, bool bAddSails, bool bAutoPilotShip) { NativeCall<void, FString*, float, bool, bool, bool>(this, "UShooterCheatManager.SpawnShipFast", ShipName, SpawnDist, bAddDecks, bAddSails, bAutoPilotShip); }

    void SpawnShipFastEx(FString* ShipBPName, FString* HullBPName, bool bAddDecks, bool bAddSails) { NativeCall<void, FString*, FString*, bool, bool>(this, "UShooterCheatManager.SpawnShipFastEx", ShipBPName, HullBPName, bAddDecks, bAddSails); }

    void SpawnWorldActor(FString* blueprintPath, float x, float y) { NativeCall<void, FString*, float, float>(this, "UShooterCheatManager.SpawnWorldActor", blueprintPath, x, y); }

    void StartSaveBackup() { NativeCall<void>(this, "UShooterCheatManager.StartSaveBackup"); }

    void StartWildDinos() { NativeCall<void>(this, "UShooterCheatManager.StartWildDinos"); }

    void StopWildDinos() { NativeCall<void>(this, "UShooterCheatManager.StopWildDinos"); }

    void StressTestShip(int Ship, int X, int Y, float TimeToLive, float SpeedMultiplier) { NativeCall<void, int, int, int, float, float>(this, "UShooterCheatManager.StressTestShip", Ship, X, Y, TimeToLive, SpeedMultiplier); }

    void StressTestTravel() { NativeCall<void>(this, "UShooterCheatManager.StressTestTravel"); }

    void StressTestTravelStartLoop(float IntervalSec) { NativeCall<void, float>(this, "UShooterCheatManager.StressTestTravelStartLoop", IntervalSec); }

    void Suicide() { NativeCall<void>(this, "UShooterCheatManager.Suicide"); }

    void Summon(FString* ClassName) { NativeCall<void, FString*>(this, "UShooterCheatManager.Summon", ClassName); }

    void SummonTamed(FString* ClassName) { NativeCall<void, FString*>(this, "UShooterCheatManager.SummonTamed", ClassName); }

    void TP(FString LocationName) { NativeCall<void, FString>(this, "UShooterCheatManager.TP", LocationName); }

    void TakeAllDino() { NativeCall<void>(this, "UShooterCheatManager.TakeAllDino"); }

    void TakeAllStructure() { NativeCall<void>(this, "UShooterCheatManager.TakeAllStructure"); }

    void TeleportPlayerIDToMe(__int64 PlayerID) { NativeCall<void, __int64>(this, "UShooterCheatManager.TeleportPlayerIDToMe", PlayerID); }

    void TeleportPlayerNameToMe(FString* PlayerName) { NativeCall<void, FString*>(this, "UShooterCheatManager.TeleportPlayerNameToMe", PlayerName); }

    void TeleportToActorLocation(FString* ActorName) { NativeCall<void, FString*>(this, "UShooterCheatManager.TeleportToActorLocation", ActorName); }

    void TeleportToPlayer(__int64 PlayerID) { NativeCall<void, __int64>(this, "UShooterCheatManager.TeleportToPlayer", PlayerID); }

    void TeleportToTreasure() { NativeCall<void>(this, "UShooterCheatManager.TeleportToTreasure"); }

    void ToggleGun() { NativeCall<void>(this, "UShooterCheatManager.ToggleGun"); }

    void ToggleHud() { NativeCall<void>(this, "UShooterCheatManager.ToggleHud"); }

    void ToggleLocation() { NativeCall<void>(this, "UShooterCheatManager.ToggleLocation"); }

    void TribeMOTD(__int64 TribeTeamID, FString Message) { NativeCall<void, __int64, FString>(this, "UShooterCheatManager.TribeMOTD", TribeTeamID, Message); }

    void TribeMessage(__int64 TribeTeamID, FString Message) { NativeCall<void, __int64, FString>(this, "UShooterCheatManager.TribeMessage", TribeTeamID, Message); }

    void TribeMessageNoNotification(__int64 TribeTeamID, FString Message) { NativeCall<void, __int64, FString>(this, "UShooterCheatManager.TribeMessageNoNotification", TribeTeamID, Message); }

    void TribeStructureAudit(__int64 TribeTeamID) { NativeCall<void, __int64>(this, "UShooterCheatManager.TribeStructureAudit", TribeTeamID); }

    void UnbanPlayer(FString PlayerSteamName) { NativeCall<void, FString>(this, "UShooterCheatManager.UnbanPlayer", PlayerSteamName); }

    void UnlockEngram(FString* ItemClassName) { NativeCall<void, FString*>(this, "UShooterCheatManager.UnlockEngram", ItemClassName); }

    void VisualizeClass(FString* ClassIn, int MaxTotal) { NativeCall<void, FString*, int>(this, "UShooterCheatManager.VisualizeClass", ClassIn, MaxTotal); }

    void psc(FString* command) { NativeCall<void, FString*>(this, "UShooterCheatManager.psc", command); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "UShooterCheatManager.GetPrivateStaticClass", Package); }

    static void StaticRegisterNativesUShooterCheatManager() { NativeCall<void>(nullptr, "UShooterCheatManager.StaticRegisterNativesUShooterCheatManager"); }

};


struct UPlayer

{

    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); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "UPlayer.GetPrivateStaticClass", Package); }

};


struct APlayerState : AActor

{

    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


    void ClientInitialize(AController* C) { NativeCall<void, AController*>(this, "APlayerState.ClientInitialize", C); }

    void CopyProperties(APlayerState* PlayerState) { NativeCall<void, APlayerState*>(this, "APlayerState.CopyProperties", PlayerState); }

    void Destroyed() { NativeCall<void>(this, "APlayerState.Destroyed"); }

    APlayerState* Duplicate() { return NativeCall<APlayerState*>(this, "APlayerState.Duplicate"); }

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

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "APlayerState.GetLifetimeReplicatedProps", OutLifetimeProps); }

    void OnRep_PlayerName() { NativeCall<void>(this, "APlayerState.OnRep_PlayerName"); }

    void OnRep_UniqueId() { NativeCall<void>(this, "APlayerState.OnRep_UniqueId"); }

    void OnRep_bIsInactive() { NativeCall<void>(this, "APlayerState.OnRep_bIsInactive"); }

    void OverrideWith(APlayerState* PlayerState) { NativeCall<void, APlayerState*>(this, "APlayerState.OverrideWith", PlayerState); }

    void PostInitializeComponents() { NativeCall<void>(this, "APlayerState.PostInitializeComponents"); }

    void RecalculateAvgPing() { NativeCall<void>(this, "APlayerState.RecalculateAvgPing"); }

    void RegisterPlayerWithSession(bool bWasFromInvite) { NativeCall<void, bool>(this, "APlayerState.RegisterPlayerWithSession", bWasFromInvite); }

    void Reset() { NativeCall<void>(this, "APlayerState.Reset"); }

    void SeamlessTravelTo(APlayerState* NewPlayerState) { NativeCall<void, APlayerState*>(this, "APlayerState.SeamlessTravelTo", NewPlayerState); }

    void SetPlayerName(FString* S) { NativeCall<void, FString*>(this, "APlayerState.SetPlayerName", S); }

    void SetUniqueId(TSharedPtr<FUniqueNetId, 0>* InUniqueId) { NativeCall<void, TSharedPtr<FUniqueNetId, 0>*>(this, "APlayerState.SetUniqueId", InUniqueId); }

    bool ShouldBroadCastWelcomeMessage(bool bExiting) { return NativeCall<bool, bool>(this, "APlayerState.ShouldBroadCastWelcomeMessage", bExiting); }

    void UnregisterPlayerWithSession() { NativeCall<void>(this, "APlayerState.UnregisterPlayerWithSession"); }

    void UpdatePing(float InPing) { NativeCall<void, float>(this, "APlayerState.UpdatePing", InPing); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "APlayerState.GetPrivateStaticClass", Package); }

    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<TSubclassOf<APrimalBuff>, 10> FeatHotkeysField() { return { this, "AShooterPlayerState.FeatHotkeys" }; }

    FieldArray<char, 10> DefaultItemSlotEngramsField() { return { this, "AShooterPlayerState.DefaultItemSlotEngrams" }; }

    FTribeData& NullTribeDataField() { return *GetNativePointerField<FTribeData*>(this, "AShooterPlayerState.NullTribeData"); }

    FTribeData* CurrentTribeDataPtrField() { return *GetNativePointerField<FTribeData**>(this, "AShooterPlayerState.CurrentTribeDataPtr"); }

    FTribeData* LastTribeInviteDataField() { return GetNativePointerField<FTribeData*>(this, "AShooterPlayerState.LastTribeInviteData"); }

    long double& ReplicatePlayerDataUntilTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerState.ReplicatePlayerDataUntilTime"); }

    long double& ReplicateSkillsUntilTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerState.ReplicateSkillsUntilTime"); }

    int& LastTribeDataChangedFrameField() { return *GetNativePointerField<int*>(this, "AShooterPlayerState.LastTribeDataChangedFrame"); }

    bool& bSendSpawnPointsField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerState.bSendSpawnPoints"); }

    TArray<FSpawnPointInfo>& CachedSpawnPointInfosField() { return *GetNativePointerField<TArray<FSpawnPointInfo>*>(this, "AShooterPlayerState.CachedSpawnPointInfos"); }

    TArray<UDiscoveryZoneDataListEntry*> DiscoveryZoneEntryObjectsField() { return *GetNativePointerField<TArray<UDiscoveryZoneDataListEntry*>*>(this, "AShooterPlayerState.DiscoveryZoneEntryObjects"); }

    int& TotalEngramPointsField() { return *GetNativePointerField<int*>(this, "AShooterPlayerState.TotalEngramPoints"); }

    int& FreeEngramPointsField() { return *GetNativePointerField<int*>(this, "AShooterPlayerState.FreeEngramPoints"); }

    TSet<TSubclassOf<UPrimalItem>, DefaultKeyFuncs<TSubclassOf<UPrimalItem>, 0>, FDefaultSetAllocator>& ServerEngramItemBlueprintsSetField() { return *GetNativePointerField<TSet<TSubclassOf<UPrimalItem>, DefaultKeyFuncs<TSubclassOf<UPrimalItem>, 0>, FDefaultSetAllocator>*>(this, "AShooterPlayerState.ServerEngramItemBlueprintsSet"); }

    TArray<TSubclassOf<UPrimalEngramEntry>>& UnlockedSkillsField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalEngramEntry>>*>(this, "AShooterPlayerState.UnlockedSkills"); }

    TSet<TSubclassOf<UPrimalEngramEntry>, DefaultKeyFuncs<TSubclassOf<UPrimalEngramEntry>, 0>, FDefaultSetAllocator>& ServerUnlockedSkillsSetField() { return *GetNativePointerField<TSet<TSubclassOf<UPrimalEngramEntry>, DefaultKeyFuncs<TSubclassOf<UPrimalEngramEntry>, 0>, FDefaultSetAllocator>*>(this, "AShooterPlayerState.ServerUnlockedSkillsSet"); }

    TSet<TSubclassOf<APrimalBuff>, DefaultKeyFuncs<TSubclassOf<APrimalBuff>, 0>, FDefaultSetAllocator>& UnlockedFeatsSetField() { return *GetNativePointerField<TSet<TSubclassOf<APrimalBuff>, DefaultKeyFuncs<TSubclassOf<APrimalBuff>, 0>, FDefaultSetAllocator>*>(this, "AShooterPlayerState.UnlockedFeatsSet"); }

    long double& NextAllowedRespawnTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerState.NextAllowedRespawnTime"); }

    float& AllowedRespawnIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerState.AllowedRespawnInterval"); }

    long double& LastTimeDiedToEnemyTeamField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerState.LastTimeDiedToEnemyTeam"); }

    bool& bSuppressEngramNetworkingField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerState.bSuppressEngramNetworking"); }

    int& CurrentlySelectedDinoOrderGroupField() { return *GetNativePointerField<int*>(this, "AShooterPlayerState.CurrentlySelectedDinoOrderGroup"); }

    FTameUnitCounts& CurrentTameUnitCountsField() { return *GetNativePointerField<FTameUnitCounts*>(this, "AShooterPlayerState.CurrentTameUnitCounts"); }

    long double& NextAllowedTerritoryMessageTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerState.NextAllowedTerritoryMessageTime"); }

    long double& NextAllowedTribeJoinTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerState.NextAllowedTribeJoinTime"); }

    FieldArray<FDinoOrderGroup, 10> DinoOrderGroupsField() { return { this, "AShooterPlayerState.DinoOrderGroups" }; }

    TArray<UPrimalItem*> KnownCraftableItemsField() { return *GetNativePointerField<TArray<UPrimalItem*>*>(this, "AShooterPlayerState.KnownCraftableItems"); }

    bool& bUpdatingClientEntityLocsField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerState.bUpdatingClientEntityLocs"); }

    long double& LastTribeRequestTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerState.LastTribeRequestTime"); }


    // Bit fields


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


    // Functions


    void AcceptJoinAlliance(unsigned int AllianceID, unsigned int NewMemberID, FString NewMemberName) { NativeCall<void, unsigned int, unsigned int, FString>(this, "AShooterPlayerState.AcceptJoinAlliance", AllianceID, NewMemberID, NewMemberName); }

    void AddEngramBlueprintToPlayerInventory(UPrimalInventoryComponent* invComp, TSubclassOf<UPrimalItem> engramItemBlueprint) { NativeCall<void, UPrimalInventoryComponent*, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerState.AddEngramBlueprintToPlayerInventory", invComp, engramItemBlueprint); }

    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); }

    bool AllowDinoOrderByGroup(APrimalDinoCharacter* orderDino) { return NativeCall<bool, APrimalDinoCharacter*>(this, "AShooterPlayerState.AllowDinoOrderByGroup", orderDino); }

    bool AllowTribeGroupPermission(ETribeGroupPermission::Type TribeGroupPermission, UObject* OnObject) { return NativeCall<bool, ETribeGroupPermission::Type, UObject*>(this, "AShooterPlayerState.AllowTribeGroupPermission", TribeGroupPermission, OnObject); }

    void ApplyEngramBuffs(AShooterCharacter* myChar, AShooterPlayerController* OverridePC) { NativeCall<void, AShooterCharacter*, AShooterPlayerController*>(this, "AShooterPlayerState.ApplyEngramBuffs", myChar, OverridePC); }

    void ApplyEngramStatModifiers(AShooterCharacter* myChar) { NativeCall<void, AShooterCharacter*>(this, "AShooterPlayerState.ApplyEngramStatModifiers", myChar); }

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

    void BroadcastDeath_Implementation(AShooterPlayerState* KillerPlayerState, UDamageType* KillerDamageType, AShooterPlayerState* KilledPlayerState) { NativeCall<void, AShooterPlayerState*, UDamageType*, AShooterPlayerState*>(this, "AShooterPlayerState.BroadcastDeath_Implementation", KillerPlayerState, KillerDamageType, KilledPlayerState); }

    void ClearKnownCraftables() { NativeCall<void>(this, "AShooterPlayerState.ClearKnownCraftables"); }

    void ClearTribe(bool bDontRemoveFromTribe, bool bForce, APlayerController* ForPC) { NativeCall<void, bool, bool, APlayerController*>(this, "AShooterPlayerState.ClearTribe", bDontRemoveFromTribe, bForce, ForPC); }

    void ClearTribeBasic() { NativeCall<void>(this, "AShooterPlayerState.ClearTribeBasic"); }

    void ClientGetPlayerBannedData_Implementation(TArray<FAdminPlayerDataInfo>* list) { NativeCall<void, TArray<FAdminPlayerDataInfo>*>(this, "AShooterPlayerState.ClientGetPlayerBannedData_Implementation", list); }

    void ClientGetPlayerConnectedData_Implementation(TArray<FAdminPlayerDataInfo>* list) { NativeCall<void, TArray<FAdminPlayerDataInfo>*>(this, "AShooterPlayerState.ClientGetPlayerConnectedData_Implementation", list); }

    void ClientGetPlayerWhiteListedData_Implementation(TArray<FAdminPlayerDataInfo>* list) { NativeCall<void, TArray<FAdminPlayerDataInfo>*>(this, "AShooterPlayerState.ClientGetPlayerWhiteListedData_Implementation", list); }

    void ClientGetServerOptions_Implementation(FServerOptions info) { NativeCall<void, FServerOptions>(this, "AShooterPlayerState.ClientGetServerOptions_Implementation", info); }

    void ClientInitialize(AController* InController) { NativeCall<void, AController*>(this, "AShooterPlayerState.ClientInitialize", InController); }

    void ClientNotifyLevelUpAvailable_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ClientNotifyLevelUpAvailable_Implementation"); }

    void ClientReceiveAvailableEntities_Implementation(TArray<FTribeEntity>* AvailableEntities) { NativeCall<void, TArray<FTribeEntity>*>(this, "AShooterPlayerState.ClientReceiveAvailableEntities_Implementation", AvailableEntities); }

    void ClientReceivePartialSpawnPointUpdates_Implementation(TArray<FSpawnPointInfo>* SpawnPointsInfos) { NativeCall<void, TArray<FSpawnPointInfo>*>(this, "AShooterPlayerState.ClientReceivePartialSpawnPointUpdates_Implementation", SpawnPointsInfos); }

    void ClientReceiveSpawnPoints_Implementation(TArray<FSpawnPointInfo>* SpawnPointsInfos) { NativeCall<void, TArray<FSpawnPointInfo>*>(this, "AShooterPlayerState.ClientReceiveSpawnPoints_Implementation", SpawnPointsInfos); }

    void ClientRefreshDinoOrderGroup_Implementation(int groupIndex, FDinoOrderGroup groupData, int UseCurrentlySelectedGroup) { NativeCall<void, int, FDinoOrderGroup, int>(this, "AShooterPlayerState.ClientRefreshDinoOrderGroup_Implementation", groupIndex, groupData, UseCurrentlySelectedGroup); }

    void ClientUnlockedFeat_Implementation(FName FeatName) { NativeCall<void, FName>(this, "AShooterPlayerState.ClientUnlockedFeat_Implementation", FeatName); }

    void ClientUpdateTameUnitCounts_Implementation(FTameUnitCounts NewTameUnitCounts) { NativeCall<void, FTameUnitCounts>(this, "AShooterPlayerState.ClientUpdateTameUnitCounts_Implementation", NewTameUnitCounts); }

    void CompletePointOfInterest(int PointOfInterestID) { NativeCall<void, int>(this, "AShooterPlayerState.CompletePointOfInterest", PointOfInterestID); }

    void CompleteQuest(int QuestID) { NativeCall<void, int>(this, "AShooterPlayerState.CompleteQuest", QuestID); }

    void CopyProperties(APlayerState* PlayerState) { NativeCall<void, APlayerState*>(this, "AShooterPlayerState.CopyProperties", PlayerState); }

    void Destroyed() { NativeCall<void>(this, "AShooterPlayerState.Destroyed"); }

    void DoRespec(UPrimalPlayerData* ForPlayerData, AShooterCharacter* ForCharacter, bool bSetRespecedAtCharacterLevel) { NativeCall<void, UPrimalPlayerData*, AShooterCharacter*, bool>(this, "AShooterPlayerState.DoRespec", ForPlayerData, ForCharacter, bSetRespecedAtCharacterLevel); }

    int GetCharacterLevel() { return NativeCall<int>(this, "AShooterPlayerState.GetCharacterLevel"); }

    FString* GetDinoOrderGroupName(FString* result, int groupIndex) { return NativeCall<FString*, FString*, int>(this, "AShooterPlayerState.GetDinoOrderGroupName", result, groupIndex); }

    int GetGlobalNumOfShipsForTribe() { return NativeCall<int>(this, "AShooterPlayerState.GetGlobalNumOfShipsForTribe"); }

    UPrimalItem* GetItemForUnlockedFeat(AShooterCharacter* myChar, TSubclassOf<APrimalBuff> FeatClass) { return NativeCall<UPrimalItem*, AShooterCharacter*, TSubclassOf<APrimalBuff>>(this, "AShooterPlayerState.GetItemForUnlockedFeat", myChar, FeatClass); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "AShooterPlayerState.GetLifetimeReplicatedProps", OutLifetimeProps); }

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

    int GetNumDiscoveryZonesFound() { return NativeCall<int>(this, "AShooterPlayerState.GetNumDiscoveryZonesFound"); }

    int GetNumDiscoveryZonesFoundInServer(const unsigned int* ServerID) { return NativeCall<int, const unsigned int*>(this, "AShooterPlayerState.GetNumDiscoveryZonesFoundInServer", ServerID); }

    int GetNumDiscoveryZonesInServer(const unsigned int* ServerID) { return NativeCall<int, const unsigned int*>(this, "AShooterPlayerState.GetNumDiscoveryZonesInServer", ServerID); }

    int GetNumDiscoveryZonesTotal() { return NativeCall<int>(this, "AShooterPlayerState.GetNumDiscoveryZonesTotal"); }

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

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

    AShooterPlayerController* GetShooterController() { return NativeCall<AShooterPlayerController*>(this, "AShooterPlayerState.GetShooterController"); }

    float GetTameUnitCount(ETameUnitType::Type TheTameUnitType) { return NativeCall<float, ETameUnitType::Type>(this, "AShooterPlayerState.GetTameUnitCount", TheTameUnitType); }

    int GetTribeId() { return NativeCall<int>(this, "AShooterPlayerState.GetTribeId"); }

    FTribeWar* GetTribeWar(FTribeWar* result, int EnemyTeam) { return NativeCall<FTribeWar*, FTribeWar*, int>(this, "AShooterPlayerState.GetTribeWar", result, EnemyTeam); }

    UObject* GetObjectW() { return NativeCall<UObject*>(this, "AShooterPlayerState.GetObjectW"); }

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

    bool HasCompletedQuest(int QuestID) { return NativeCall<bool, int>(this, "AShooterPlayerState.HasCompletedQuest", QuestID); }

    bool HasCompletedQuestPointOfInterest(int PointOfInterestID) { return NativeCall<bool, int>(this, "AShooterPlayerState.HasCompletedQuestPointOfInterest", PointOfInterestID); }

    bool HasDefaultExtraInventoryItem(TSubclassOf<UPrimalItem> ItemClass) { return NativeCall<bool, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerState.HasDefaultExtraInventoryItem", ItemClass); }

    bool HasDiscipline(EEngramDiscipline::Type ForDiscipline) { return NativeCall<bool, EEngramDiscipline::Type>(this, "AShooterPlayerState.HasDiscipline", ForDiscipline); }

    bool HasDiscoveredDiscoveryZone(int ZoneId) { return NativeCall<bool, int>(this, "AShooterPlayerState.HasDiscoveredDiscoveryZone", ZoneId); }

    bool HasEngram(TSubclassOf<UPrimalItem> ItemClass) { return NativeCall<bool, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerState.HasEngram", ItemClass); }

    bool HasSkill(TSubclassOf<UPrimalEngramEntry> SkillClass) { return NativeCall<bool, TSubclassOf<UPrimalEngramEntry>>(this, "AShooterPlayerState.HasSkill", SkillClass); }

    bool HasTribeWarRequest(int EnemyTeam) { return NativeCall<bool, int>(this, "AShooterPlayerState.HasTribeWarRequest", EnemyTeam); }

    void InitializeDiscoveryZoneEntryObjects() { NativeCall<void>(this, "AShooterPlayerState.InitializeDiscoveryZoneEntryObjects"); }

    void InvitedRankGroupPlayerIntoTribe(AShooterPlayerState* OtherPlayer) { NativeCall<void, AShooterPlayerState*>(this, "AShooterPlayerState.InvitedRankGroupPlayerIntoTribe", OtherPlayer); }

    bool IsAlliedWith(int OtherTeam) { return NativeCall<bool, int>(this, "AShooterPlayerState.IsAlliedWith", OtherTeam); }

    bool IsDinoClassInOrderGroup(int groupIndex, TSubclassOf<APrimalDinoCharacter> dinoClass) { return NativeCall<bool, int, TSubclassOf<APrimalDinoCharacter>>(this, "AShooterPlayerState.IsDinoClassInOrderGroup", groupIndex, dinoClass); }

    bool IsDinoInOrderGroup(int groupIndex, APrimalDinoCharacter* dinoChar) { return NativeCall<bool, int, APrimalDinoCharacter*>(this, "AShooterPlayerState.IsDinoInOrderGroup", groupIndex, dinoChar); }

    bool IsInTribe() { return NativeCall<bool>(this, "AShooterPlayerState.IsInTribe"); }

    bool IsInTribeWar(int EnemyTeam) { return NativeCall<bool, int>(this, "AShooterPlayerState.IsInTribeWar", EnemyTeam); }

    bool IsTribeAdmin() { return NativeCall<bool>(this, "AShooterPlayerState.IsTribeAdmin"); }

    bool IsTribeFounder() { return NativeCall<bool>(this, "AShooterPlayerState.IsTribeFounder"); }

    bool IsTribeOwner(unsigned int CheckPlayerDataID) { return NativeCall<bool, unsigned int>(this, "AShooterPlayerState.IsTribeOwner", CheckPlayerDataID); }

    void LocalDoUpdateTribeEntityLocs() { NativeCall<void>(this, "AShooterPlayerState.LocalDoUpdateTribeEntityLocs"); }

    void LocalSetSelectedDinoOrderGroup(int newGroup, bool bDontToggle) { NativeCall<void, int, bool>(this, "AShooterPlayerState.LocalSetSelectedDinoOrderGroup", newGroup, bDontToggle); }

    void NotifyPlayerJoinedTribe_Implementation(FString* ThePlayerName, FString* TribeName) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerState.NotifyPlayerJoinedTribe_Implementation", ThePlayerName, TribeName); }

    void NotifyPlayerJoined_Implementation(FString* ThePlayerName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyPlayerJoined_Implementation", ThePlayerName); }

    void NotifyPlayerLeftTribe_Implementation(FString* ThePlayerName, FString* TribeName) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerState.NotifyPlayerLeftTribe_Implementation", ThePlayerName, TribeName); }

    void NotifyPlayerLeft_Implementation(FString* ThePlayerName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyPlayerLeft_Implementation", ThePlayerName); }

    void NotifyTribememberJoined_Implementation(FString* ThePlayerName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyTribememberJoined_Implementation", ThePlayerName); }

    void NotifyTribememberLeft_Implementation(FString* ThePlayerName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyTribememberLeft_Implementation", ThePlayerName); }

    void OnRep_MyPlayerDataStruct() { NativeCall<void>(this, "AShooterPlayerState.OnRep_MyPlayerDataStruct"); }

    void OnRep_UpdatedSkills() { NativeCall<void>(this, "AShooterPlayerState.OnRep_UpdatedSkills"); }

    void PromoteToTribeAdmin(APlayerController* PromoterPC) { NativeCall<void, APlayerController*>(this, "AShooterPlayerState.PromoteToTribeAdmin", PromoterPC); }

    void ReceivedPlayerCharacter(AShooterCharacter* NewPawn) { NativeCall<void, AShooterCharacter*>(this, "AShooterPlayerState.ReceivedPlayerCharacter", NewPawn); }

    void RequestCreateNewPlayerWithArkData(UPrimalPlayerData* PlayerArkData) { NativeCall<void, UPrimalPlayerData*>(this, "AShooterPlayerState.RequestCreateNewPlayerWithArkData", PlayerArkData); }

    void Reset() { NativeCall<void>(this, "AShooterPlayerState.Reset"); }

    void ResetPlayerDataBornAtTime() { NativeCall<void>(this, "AShooterPlayerState.ResetPlayerDataBornAtTime"); }

    void SendAvailableEntitiesFromAllServersToClient(TArray<FTribeEntity>* AvailableEntitiesFromOtherServers, int IgnoreBedID) { NativeCall<void, TArray<FTribeEntity>*, int>(this, "AShooterPlayerState.SendAvailableEntitiesFromAllServersToClient", AvailableEntitiesFromOtherServers, IgnoreBedID); }

    void SendTribeInviteData_Implementation(FTribeData TribeInviteData) { NativeCall<void, FTribeData>(this, "AShooterPlayerState.SendTribeInviteData_Implementation", TribeInviteData); }

    void ServerAcceptTribeWar_Implementation(int EnemyTeamID) { NativeCall<void, int>(this, "AShooterPlayerState.ServerAcceptTribeWar_Implementation", EnemyTeamID); }

    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 ServerDinoOrderGroup_AddOrRemoveDinoCharacter_Implementation(int groupIndex, APrimalDinoCharacter* DinoCharacter, bool bAdd) { NativeCall<void, int, APrimalDinoCharacter*, bool>(this, "AShooterPlayerState.ServerDinoOrderGroup_AddOrRemoveDinoCharacter_Implementation", groupIndex, DinoCharacter, bAdd); }

    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 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 ServerGetAlivePlayerConnectedData_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerGetAlivePlayerConnectedData_Implementation"); }

    void ServerGetAllPlayerNamesAndLocations_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerGetAllPlayerNamesAndLocations_Implementation"); }

    void ServerGetPlayerBannedData_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerGetPlayerBannedData_Implementation"); }

    void ServerGetPlayerConnectedData_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerGetPlayerConnectedData_Implementation"); }

    void ServerGetPlayerWhiteListedData_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerGetPlayerWhiteListedData_Implementation"); }

    void ServerGetServerOptions_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerGetServerOptions_Implementation"); }

    void ServerRejectTribeWar_Implementation(int EnemyTeamID) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRejectTribeWar_Implementation", EnemyTeamID); }

    void ServerRequestApplyEngramPoints_Implementation(TSubclassOf<UPrimalEngramEntry> forItemEntry, EEngramDiscipline::Type ForDiscipline) { NativeCall<void, TSubclassOf<UPrimalEngramEntry>, EEngramDiscipline::Type>(this, "AShooterPlayerState.ServerRequestApplyEngramPoints_Implementation", forItemEntry, ForDiscipline); }

    void ServerRequestCreateNewTribe_Implementation(FString* TribeName, FTribeGovernment TribeGovernment) { NativeCall<void, FString*, FTribeGovernment>(this, "AShooterPlayerState.ServerRequestCreateNewTribe_Implementation", TribeName, TribeGovernment); }

    void ServerRequestDemotePlayerInMyTribe_Implementation(int PlayerIndexInTribe) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRequestDemotePlayerInMyTribe_Implementation", PlayerIndexInTribe); }

    void ServerRequestDinoOrderGroups_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerRequestDinoOrderGroups_Implementation"); }

    void ServerRequestLeaveAlliance_Implementation(unsigned int AllianceID) { NativeCall<void, unsigned int>(this, "AShooterPlayerState.ServerRequestLeaveAlliance_Implementation", AllianceID); }

    void ServerRequestLeaveTribe_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerRequestLeaveTribe_Implementation"); }

    void ServerRequestMySpawnPoints_Implementation(unsigned int IgnoreBedID, TSubclassOf<APrimalStructure> FilterClass) { NativeCall<void, unsigned int, TSubclassOf<APrimalStructure>>(this, "AShooterPlayerState.ServerRequestMySpawnPoints_Implementation", IgnoreBedID, FilterClass); }

    void ServerRequestPartialSpawnPointUpdate_Implementation(unsigned int EntityID) { NativeCall<void, unsigned int>(this, "AShooterPlayerState.ServerRequestPartialSpawnPointUpdate_Implementation", EntityID); }

    void ServerRequestPromoteAllianceMember_Implementation(unsigned int AllianceID, unsigned int MemberID) { NativeCall<void, unsigned int, unsigned int>(this, "AShooterPlayerState.ServerRequestPromoteAllianceMember_Implementation", AllianceID, MemberID); }

    void ServerRequestPromotePlayerInMyTribe_Implementation(int PlayerIndexInTribe) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRequestPromotePlayerInMyTribe_Implementation", PlayerIndexInTribe); }

    void ServerRequestRemoveAllianceMember_Implementation(unsigned int AllianceID, unsigned int MemberID) { NativeCall<void, unsigned int, unsigned int>(this, "AShooterPlayerState.ServerRequestRemoveAllianceMember_Implementation", AllianceID, MemberID); }

    void ServerRequestRemovePlayerIndexFromMyTribe_Implementation(int PlayerIndexInTribe) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRequestRemovePlayerIndexFromMyTribe_Implementation", PlayerIndexInTribe); }

    void ServerRequestRenameTribe_Implementation(FString* newTribeName) { NativeCall<void, FString*>(this, "AShooterPlayerState.ServerRequestRenameTribe_Implementation", newTribeName); }

    void ServerRequestResetPlayer_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerRequestResetPlayer_Implementation"); }

    void ServerRequestSetTribeGovernment_Implementation(FTribeGovernment TribeGovernment) { NativeCall<void, FTribeGovernment>(this, "AShooterPlayerState.ServerRequestSetTribeGovernment_Implementation", TribeGovernment); }

    void ServerRequestSetTribeMemberGroupRank_Implementation(int PlayerIndexInTribe, int RankGroupIndex) { NativeCall<void, int, int>(this, "AShooterPlayerState.ServerRequestSetTribeMemberGroupRank_Implementation", PlayerIndexInTribe, RankGroupIndex); }

    void ServerRequestTransferOwnershipInMyTribe_Implementation(int PlayerIndexInTribe) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRequestTransferOwnershipInMyTribe_Implementation", PlayerIndexInTribe); }

    void ServerSetDefaultItemSlotClass_Implementation(int slotNum, TSubclassOf<UPrimalItem> ItemClass, bool bIsEngram) { NativeCall<void, int, TSubclassOf<UPrimalItem>, bool>(this, "AShooterPlayerState.ServerSetDefaultItemSlotClass_Implementation", slotNum, ItemClass, bIsEngram); }

    void ServerSetDinoGroupName_Implementation(int groupIndex, FString* GroupName) { NativeCall<void, int, FString*>(this, "AShooterPlayerState.ServerSetDinoGroupName_Implementation", groupIndex, GroupName); }

    void ServerSetFeatHotkey_Implementation(int slotNum, TSubclassOf<APrimalBuff> FeatClass) { NativeCall<void, int, TSubclassOf<APrimalBuff>>(this, "AShooterPlayerState.ServerSetFeatHotkey_Implementation", slotNum, FeatClass); }

    void ServerSetSelectedDinoOrderGroup_Implementation(int newGroup) { NativeCall<void, int>(this, "AShooterPlayerState.ServerSetSelectedDinoOrderGroup_Implementation", newGroup); }

    void ServerSetTribeMOTD_Implementation(FString* MOTD) { NativeCall<void, FString*>(this, "AShooterPlayerState.ServerSetTribeMOTD_Implementation", MOTD); }

    void ServerTribeRequestAddRankGroup_Implementation(FString* GroupName) { NativeCall<void, FString*>(this, "AShooterPlayerState.ServerTribeRequestAddRankGroup_Implementation", GroupName); }

    void ServerTribeRequestApplyRankGroupSettings_Implementation(int RankGroupIndex, FTribeRankGroup newGroupSettings) { NativeCall<void, int, FTribeRankGroup>(this, "AShooterPlayerState.ServerTribeRequestApplyRankGroupSettings_Implementation", RankGroupIndex, newGroupSettings); }

    void ServerTribeRequestNewAlliance_Implementation(FString* AllianceName) { NativeCall<void, FString*>(this, "AShooterPlayerState.ServerTribeRequestNewAlliance_Implementation", AllianceName); }

    void ServerTribeRequestRemoveRankGroup_Implementation(int RankGroupIndex) { NativeCall<void, int>(this, "AShooterPlayerState.ServerTribeRequestRemoveRankGroup_Implementation", RankGroupIndex); }

    void ServerUnlockEngram(TSubclassOf<UPrimalEngramEntry> forItemEntry, bool bNotifyPlayerHUD, bool bForceUnlock, EEngramDiscipline::Type ForDiscipline) { NativeCall<void, TSubclassOf<UPrimalEngramEntry>, bool, bool, EEngramDiscipline::Type>(this, "AShooterPlayerState.ServerUnlockEngram", forItemEntry, bNotifyPlayerHUD, bForceUnlock, ForDiscipline); }

    void SetQuitter(bool bInQuitter) { NativeCall<void, bool>(this, "AShooterPlayerState.SetQuitter", bInQuitter); }

    void SetTribeTamingDinoSettings(APrimalDinoCharacter* aDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterPlayerState.SetTribeTamingDinoSettings", aDinoChar); }

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

    void TransferTribalObjects(FTribeData* TribeData, bool bTransferToTribe, bool bDontIncludePlayers) { NativeCall<void, FTribeData*, bool, bool>(this, "AShooterPlayerState.TransferTribalObjects", TribeData, bTransferToTribe, bDontIncludePlayers); }

    void UnregisterPlayerWithSession() { NativeCall<void>(this, "AShooterPlayerState.UnregisterPlayerWithSession"); }

    void UpdateFeatSet(AShooterCharacter* myChar) { NativeCall<void, AShooterCharacter*>(this, "AShooterPlayerState.UpdateFeatSet", myChar); }

    void UpdateServerFullStatus() { NativeCall<void>(this, "AShooterPlayerState.UpdateServerFullStatus"); }

    void UpdateTameCounts() { NativeCall<void>(this, "AShooterPlayerState.UpdateTameCounts"); }

    void UpdateTribeData(FTribeData* TribeData) { NativeCall<void, FTribeData*>(this, "AShooterPlayerState.UpdateTribeData", TribeData); }

    void UpdatedPlayerData() { NativeCall<void>(this, "AShooterPlayerState.UpdatedPlayerData"); }

    void UpdatedSkills(AShooterCharacter* myChar, AShooterPlayerController* OverridePC) { NativeCall<void, AShooterCharacter*, AShooterPlayerController*>(this, "AShooterPlayerState.UpdatedSkills", myChar, OverridePC); }

    void BroadcastDeath(AShooterPlayerState* KillerPlayerState, UDamageType* KillerDamageType, AShooterPlayerState* KilledPlayerState) { NativeCall<void, AShooterPlayerState*, UDamageType*, AShooterPlayerState*>(this, "AShooterPlayerState.BroadcastDeath", KillerPlayerState, KillerDamageType, KilledPlayerState); }

    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 ClientReceiveAvailableEntities(TArray<FTribeEntity>* AvailableEntities) { NativeCall<void, TArray<FTribeEntity>*>(this, "AShooterPlayerState.ClientReceiveAvailableEntities", AvailableEntities); }

    void ClientReceivePartialSpawnPointUpdates(TArray<FSpawnPointInfo>* SpawnPointsInfos) { NativeCall<void, TArray<FSpawnPointInfo>*>(this, "AShooterPlayerState.ClientReceivePartialSpawnPointUpdates", SpawnPointsInfos); }

    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 ClientUnlockedFeat(FName FeatName) { NativeCall<void, FName>(this, "AShooterPlayerState.ClientUnlockedFeat", FeatName); }

    void ClientUpdateTameUnitCounts(FTameUnitCounts NewTameUnitCounts) { NativeCall<void, FTameUnitCounts>(this, "AShooterPlayerState.ClientUpdateTameUnitCounts", NewTameUnitCounts); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "AShooterPlayerState.GetPrivateStaticClass", Package); }

    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 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<UPrimalEngramEntry> forItemEntry, EEngramDiscipline::Type ForDiscipline) { NativeCall<void, TSubclassOf<UPrimalEngramEntry>, EEngramDiscipline::Type>(this, "AShooterPlayerState.ServerRequestApplyEngramPoints", forItemEntry, ForDiscipline); }

    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(unsigned int IgnoreBedID, TSubclassOf<APrimalStructure> FilterClass) { NativeCall<void, unsigned int, TSubclassOf<APrimalStructure>>(this, "AShooterPlayerState.ServerRequestMySpawnPoints", IgnoreBedID, FilterClass); }

    void ServerRequestPartialSpawnPointUpdate(unsigned int EntityID) { NativeCall<void, unsigned int>(this, "AShooterPlayerState.ServerRequestPartialSpawnPointUpdate", EntityID); }

    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 ServerRequestResetPlayer() { NativeCall<void>(this, "AShooterPlayerState.ServerRequestResetPlayer"); }

    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 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 ServerSetFeatHotkey(int slotNum, TSubclassOf<APrimalBuff> FeatClass) { NativeCall<void, int, TSubclassOf<APrimalBuff>>(this, "AShooterPlayerState.ServerSetFeatHotkey", slotNum, FeatClass); }

    void ServerSetSelectedDinoOrderGroup(int newGroup) { NativeCall<void, int>(this, "AShooterPlayerState.ServerSetSelectedDinoOrderGroup", newGroup); }

    void ServerSetTribeMOTD(FString* MOTD) { NativeCall<void, FString*>(this, "AShooterPlayerState.ServerSetTribeMOTD", MOTD); }

    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); }

    static void StaticRegisterNativesAShooterPlayerState() { NativeCall<void>(nullptr, "AShooterPlayerState.StaticRegisterNativesAShooterPlayerState"); }

};


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


    APawn* K2_GetPawn(AActor* DamageCauser) { return NativeCall<APawn*, AActor*>(this, "AController.K2_GetPawn", DamageCauser); }

    void AddPawnTickDependency(APawn* NewPawn) { NativeCall<void, APawn*>(this, "AController.AddPawnTickDependency", NewPawn); }

    void AttachToPawn(APawn* InPawn) { NativeCall<void, APawn*>(this, "AController.AttachToPawn", InPawn); }

    void ChangeState(FName NewState) { NativeCall<void, FName>(this, "AController.ChangeState", NewState); }

    void CleanupPlayerState() { NativeCall<void>(this, "AController.CleanupPlayerState"); }

    void ClientSetLocation_Implementation(FVector NewLocation, FRotator NewRotation) { NativeCall<void, FVector, FRotator>(this, "AController.ClientSetLocation_Implementation", NewLocation, NewRotation); }

    void ClientSetRotation_Implementation(FRotator NewRotation, bool bResetCamera, bool bAfterSeamlessTravel) { NativeCall<void, FRotator, bool, bool>(this, "AController.ClientSetRotation_Implementation", NewRotation, bResetCamera, bAfterSeamlessTravel); }

    void Destroyed() { NativeCall<void>(this, "AController.Destroyed"); }

    void DetachFromPawn() { NativeCall<void>(this, "AController.DetachFromPawn"); }

    void FailedToSpawnPawn() { NativeCall<void>(this, "AController.FailedToSpawnPawn"); }

    void GetActorEyesViewPoint(FVector* out_Location, FRotator* out_Rotation) { NativeCall<void, FVector*, FRotator*>(this, "AController.GetActorEyesViewPoint", out_Location, out_Rotation); }

    FRotator* GetControlRotation(FRotator* result) { return NativeCall<FRotator*, FRotator*>(this, "AController.GetControlRotation", result); }

    FRotator* GetDesiredRotation(FRotator* result) { return NativeCall<FRotator*, FRotator*>(this, "AController.GetDesiredRotation", result); }

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

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "AController.GetLifetimeReplicatedProps", OutLifetimeProps); }

    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); }

    FVector* GetNavAgentLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AController.GetNavAgentLocation", result); }

    void GetPlayerViewPoint(FVector* out_Location, FRotator* out_Rotation) { NativeCall<void, FVector*, FRotator*>(this, "AController.GetPlayerViewPoint", out_Location, out_Rotation); }

    FName* GetStateName(FName* result) { return NativeCall<FName*, FName*>(this, "AController.GetStateName", result); }

    AActor* GetViewTarget() { return NativeCall<AActor*>(this, "AController.GetViewTarget"); }

    void InitPlayerState() { NativeCall<void>(this, "AController.InitPlayerState"); }

    void InstigatedAnyDamage(float Damage, UDamageType* DamageType, AActor* DamagedActor, AActor* DamageCauser) { NativeCall<void, float, UDamageType*, AActor*, AActor*>(this, "AController.InstigatedAnyDamage", Damage, DamageType, DamagedActor, DamageCauser); }

    bool IsInState(FName InStateName) { return NativeCall<bool, FName>(this, "AController.IsInState", InStateName); }

    bool LineOfSightTo(AActor* Other, FVector ViewPoint, bool bAlternateChecks) { return NativeCall<bool, AActor*, FVector, bool>(this, "AController.LineOfSightTo", Other, ViewPoint, bAlternateChecks); }

    void OnRep_Pawn() { NativeCall<void>(this, "AController.OnRep_Pawn"); }

    void OnRep_PlayerState() { NativeCall<void>(this, "AController.OnRep_PlayerState"); }

    void PawnPendingDestroy(APawn* inPawn) { NativeCall<void, APawn*>(this, "AController.PawnPendingDestroy", inPawn); }

    void Possess(APawn* InPawn) { NativeCall<void, APawn*>(this, "AController.Possess", InPawn); }

    void PostInitializeComponents() { NativeCall<void>(this, "AController.PostInitializeComponents"); }

    void RemovePawnTickDependency(APawn* InOldPawn) { NativeCall<void, APawn*>(this, "AController.RemovePawnTickDependency", InOldPawn); }

    void Reset() { NativeCall<void>(this, "AController.Reset"); }

    void SetControlRotation(FRotator* NewRotation) { NativeCall<void, FRotator*>(this, "AController.SetControlRotation", NewRotation); }

    void SetInitialLocationAndRotation(FVector* NewLocation, FRotator* NewRotation) { NativeCall<void, FVector*, FRotator*>(this, "AController.SetInitialLocationAndRotation", NewLocation, NewRotation); }

    void SetPawn(APawn* InPawn) { NativeCall<void, APawn*>(this, "AController.SetPawn", InPawn); }

    void SetPawnFromRep(APawn* InPawn) { NativeCall<void, APawn*>(this, "AController.SetPawnFromRep", InPawn); }

    bool ShouldPostponePathUpdates() { return NativeCall<bool>(this, "AController.ShouldPostponePathUpdates"); }

    void UnPossess() { NativeCall<void>(this, "AController.UnPossess"); }

    void UpdateNavigationComponents() { NativeCall<void>(this, "AController.UpdateNavigationComponents"); }

    void ClientSetRotation(FRotator NewRotation, bool bResetCamera, bool bAfterSeamlessTravel) { NativeCall<void, FRotator, bool, bool>(this, "AController.ClientSetRotation", NewRotation, bResetCamera, bAfterSeamlessTravel); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "AController.GetPrivateStaticClass", Package); }

    void ReceiveInstigatedAnyDamage(float Damage, UDamageType* DamageType, AActor* DamagedActor, AActor* DamageCauser) { NativeCall<void, float, UDamageType*, AActor*, AActor*>(this, "AController.ReceiveInstigatedAnyDamage", Damage, DamageType, DamagedActor, DamageCauser); }

    static void StaticRegisterNativesAController() { NativeCall<void>(nullptr, "AController.StaticRegisterNativesAController"); }

};


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"); }

    TArray<FName>& PendingMapChangeLevelNamesField() { return *GetNativePointerField<TArray<FName>*>(this, "APlayerController.PendingMapChangeLevelNames"); }

    char& NetPlayerIndexField() { return *GetNativePointerField<char*>(this, "APlayerController.NetPlayerIndex"); }

    UNetConnection* PendingSwapConnectionField() { return *GetNativePointerField<UNetConnection**>(this, "APlayerController.PendingSwapConnection"); }

    UNetConnection* NetConnectionField() { return *GetNativePointerField<UNetConnection**>(this, "APlayerController.NetConnection"); }

    FRotator& RotationInputField() { return *GetNativePointerField<FRotator*>(this, "APlayerController.RotationInput"); }

    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"); }

    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"); }

    bool& bPossessedAnyPawnField() { return *GetNativePointerField<bool*>(this, "APlayerController.bPossessedAnyPawn"); }

    int& LastValidUnstasisCasterFrameField() { return *GetNativePointerField<int*>(this, "APlayerController.LastValidUnstasisCasterFrame"); }

    FVector& LastCharacterMovementTeleportUnstasisLocationField() { return *GetNativePointerField<FVector*>(this, "APlayerController.LastCharacterMovementTeleportUnstasisLocation"); }

    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> 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


    AActor* GetAimedUseActor(UActorComponent** UseComponent, int* hitBodyIndex, bool bForceUseActorLocation) { return NativeCall<AActor*, UActorComponent**, int*, bool>(this, "APlayerController.GetAimedUseActor", UseComponent, hitBodyIndex, bForceUseActorLocation); }

    static bool IsNetRelevantFor(FTimespan A, FTimespan B) { return NativeCall<bool, FTimespan, FTimespan>(nullptr, "APlayerController.IsNetRelevantFor", A, B); }

    void AcknowledgePossession(APawn* P) { NativeCall<void, APawn*>(this, "APlayerController.AcknowledgePossession", P); }

    void AddCheats(bool bForce) { NativeCall<void, bool>(this, "APlayerController.AddCheats", bForce); }

    void AddPitchInput(float Val) { NativeCall<void, float>(this, "APlayerController.AddPitchInput", Val); }

    void AddRollInput(float Val) { NativeCall<void, float>(this, "APlayerController.AddRollInput", Val); }

    void AddYawInput(float Val) { NativeCall<void, float>(this, "APlayerController.AddYawInput", Val); }

    void AutoManageActiveCameraTarget(AActor* SuggestedTarget) { NativeCall<void, AActor*>(this, "APlayerController.AutoManageActiveCameraTarget", SuggestedTarget); }

    void BeginInactiveState() { NativeCall<void>(this, "APlayerController.BeginInactiveState"); }

    void BeginSpectatingState() { NativeCall<void>(this, "APlayerController.BeginSpectatingState"); }

    void CalcCamera(float DeltaTime, FMinimalViewInfo* OutResult) { NativeCall<void, float, FMinimalViewInfo*>(this, "APlayerController.CalcCamera", DeltaTime, OutResult); }

    void Camera(FName NewMode) { NativeCall<void, FName>(this, "APlayerController.Camera", NewMode); }

    bool CanRestartPlayer() { return NativeCall<bool>(this, "APlayerController.CanRestartPlayer"); }

    void ChangeState(FName NewState) { NativeCall<void, FName>(this, "APlayerController.ChangeState", NewState); }

    void CleanUpAudioComponents() { NativeCall<void>(this, "APlayerController.CleanUpAudioComponents"); }

    void CleanupGameViewport() { NativeCall<void>(this, "APlayerController.CleanupGameViewport"); }

    void CleanupPlayerState() { NativeCall<void>(this, "APlayerController.CleanupPlayerState"); }

    void ClearAudioListenerOverride() { NativeCall<void>(this, "APlayerController.ClearAudioListenerOverride"); }

    void ClientAddTextureStreamingLoc_Implementation(FVector InLoc, float Duration, bool bOverrideLocation) { NativeCall<void, FVector, float, bool>(this, "APlayerController.ClientAddTextureStreamingLoc_Implementation", InLoc, Duration, bOverrideLocation); }

    void ClientCancelPendingMapChange_Implementation() { NativeCall<void>(this, "APlayerController.ClientCancelPendingMapChange_Implementation"); }

    void ClientCapBandwidth_Implementation(int Cap) { NativeCall<void, int>(this, "APlayerController.ClientCapBandwidth_Implementation", Cap); }

    void ClientClearCameraLensEffects_Implementation() { NativeCall<void>(this, "APlayerController.ClientClearCameraLensEffects_Implementation"); }

    void ClientCommitMapChange_Implementation() { NativeCall<void>(this, "APlayerController.ClientCommitMapChange_Implementation"); }

    void ClientEnableNetworkVoice_Implementation(bool bEnable) { NativeCall<void, bool>(this, "APlayerController.ClientEnableNetworkVoice_Implementation", bEnable); }

    void ClientFlushLevelStreaming_Implementation() { NativeCall<void>(this, "APlayerController.ClientFlushLevelStreaming_Implementation"); }

    void ClientForceGarbageCollection_Implementation() { NativeCall<void>(this, "APlayerController.ClientForceGarbageCollection_Implementation"); }

    void ClientGameEnded_Implementation(AActor* EndGameFocus, bool bIsWinner) { NativeCall<void, AActor*, bool>(this, "APlayerController.ClientGameEnded_Implementation", EndGameFocus, bIsWinner); }

    void ClientGotoState_Implementation(FName NewState) { NativeCall<void, FName>(this, "APlayerController.ClientGotoState_Implementation", NewState); }

    void ClientIgnoreLookInput_Implementation(bool bIgnore) { NativeCall<void, bool>(this, "APlayerController.ClientIgnoreLookInput_Implementation", bIgnore); }

    void ClientIgnoreMoveInput_Implementation(bool bIgnore) { NativeCall<void, bool>(this, "APlayerController.ClientIgnoreMoveInput_Implementation", bIgnore); }

    void ClientMessage_Implementation(FString* S, FName Type, float MsgLifeTime) { NativeCall<void, FString*, FName, float>(this, "APlayerController.ClientMessage_Implementation", S, Type, MsgLifeTime); }

    void ClientMutePlayer_Implementation(FUniqueNetIdRepl PlayerId) { NativeCall<void, FUniqueNetIdRepl>(this, "APlayerController.ClientMutePlayer_Implementation", PlayerId); }

    void ClientNetGUIDActorDeletion_Implementation(FNetworkGUID TheNetGUID) { NativeCall<void, FNetworkGUID>(this, "APlayerController.ClientNetGUIDActorDeletion_Implementation", TheNetGUID); }

    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); }

    void ClientPlaySound_Implementation(USoundBase* Sound, float VolumeMultiplier, float PitchMultiplier) { NativeCall<void, USoundBase*, float, float>(this, "APlayerController.ClientPlaySound_Implementation", Sound, VolumeMultiplier, PitchMultiplier); }

    void ClientPrepareMapChange_Implementation(FName LevelName, bool bFirst, bool bLast) { NativeCall<void, FName, bool, bool>(this, "APlayerController.ClientPrepareMapChange_Implementation", LevelName, bFirst, bLast); }

    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 ClientProcessNetExecCommandUnreliable_Implementation(AActor* ForActor, FName CommandName, FNetExecParams ExecParams) { NativeCall<void, AActor*, FName, FNetExecParams>(this, "APlayerController.ClientProcessNetExecCommandUnreliable_Implementation", ForActor, CommandName, ExecParams); }

    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); }

    void ClientReset_Implementation() { NativeCall<void>(this, "APlayerController.ClientReset_Implementation"); }

    void ClientRestart_Implementation(APawn* NewPawn) { NativeCall<void, APawn*>(this, "APlayerController.ClientRestart_Implementation", NewPawn); }

    void ClientRetryClientRestart_Implementation(APawn* NewPawn) { NativeCall<void, APawn*>(this, "APlayerController.ClientRetryClientRestart_Implementation", NewPawn); }

    void ClientReturnToMainMenu_Implementation(FString* ReturnReason) { NativeCall<void, FString*>(this, "APlayerController.ClientReturnToMainMenu_Implementation", ReturnReason); }

    void ClientSetBlockOnAsyncLoading_Implementation() { NativeCall<void>(this, "APlayerController.ClientSetBlockOnAsyncLoading_Implementation"); }

    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 SetCameraMode(FName NewCamMode) { NativeCall<void, FName>(this, "APlayerController.SetCameraMode", NewCamMode); }

    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 ClientSetForceMipLevelsToBeResident_Implementation(UMaterialInterface* Material, float ForceDuration, int CinematicTextureGroups) { NativeCall<void, UMaterialInterface*, float, int>(this, "APlayerController.ClientSetForceMipLevelsToBeResident_Implementation", Material, ForceDuration, CinematicTextureGroups); }

    void ClientSetHUD_Implementation(TSubclassOf<AHUD> NewHUDClass) { NativeCall<void, TSubclassOf<AHUD>>(this, "APlayerController.ClientSetHUD_Implementation", NewHUDClass); }

    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 ClientUnmutePlayer_Implementation(FUniqueNetIdRepl PlayerId) { NativeCall<void, FUniqueNetIdRepl>(this, "APlayerController.ClientUnmutePlayer_Implementation", PlayerId); }

    void ClientVoiceHandshakeComplete_Implementation() { NativeCall<void>(this, "APlayerController.ClientVoiceHandshakeComplete_Implementation"); }

    void ClientWasKicked_Implementation(FText* KickReason) { NativeCall<void, FText*>(this, "APlayerController.ClientWasKicked_Implementation", KickReason); }

    FString* ConsoleCommand(FString* result, FString* Cmd, bool bWriteToLog) { return NativeCall<FString*, FString*, FString*, bool>(this, "APlayerController.ConsoleCommand", result, Cmd, bWriteToLog); }

    void CreateTouchInterface() { NativeCall<void>(this, "APlayerController.CreateTouchInterface"); }

    bool DefaultCanUnpause() { return NativeCall<bool>(this, "APlayerController.DefaultCanUnpause"); }

    void DelayedNetCleanup() { NativeCall<void>(this, "APlayerController.DelayedNetCleanup"); }

    void DelayedPrepareMapChange() { NativeCall<void>(this, "APlayerController.DelayedPrepareMapChange"); }

    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); }

    void DestroySpectatorPawn() { NativeCall<void>(this, "APlayerController.DestroySpectatorPawn"); }

    void Destroyed() { NativeCall<void>(this, "APlayerController.Destroyed"); }

    void DisableInput(APlayerController* PlayerController) { NativeCall<void, APlayerController*>(this, "APlayerController.DisableInput", PlayerController); }

    void EnableCheats(FString pass) { NativeCall<void, FString>(this, "APlayerController.EnableCheats", pass); }

    void EnableInput(APlayerController* PlayerController) { NativeCall<void, APlayerController*>(this, "APlayerController.EnableInput", PlayerController); }

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

    void EndPlayingState() { NativeCall<void>(this, "APlayerController.EndPlayingState"); }

    void EndSpectatingState() { NativeCall<void>(this, "APlayerController.EndSpectatingState"); }

    void FOV(float F) { NativeCall<void, float>(this, "APlayerController.FOV", F); }

    void FailedToSpawnPawn() { NativeCall<void>(this, "APlayerController.FailedToSpawnPawn"); }

    void FlushPressedKeys() { NativeCall<void>(this, "APlayerController.FlushPressedKeys"); }

    void ForceSingleNetUpdateFor(AActor* Target) { NativeCall<void, AActor*>(this, "APlayerController.ForceSingleNetUpdateFor", Target); }

    void GameHasEnded(AActor* EndGameFocus, bool bIsWinner) { NativeCall<void, AActor*, bool>(this, "APlayerController.GameHasEnded", EndGameFocus, bIsWinner); }

    void GetActorEyesViewPoint(FVector* out_Location, FRotator* out_Rotation) { NativeCall<void, FVector*, FRotator*>(this, "APlayerController.GetActorEyesViewPoint", out_Location, out_Rotation); }

    void GetAudioListenerPosition(FVector* OutLocation, FVector* OutFrontDir, FVector* OutRightDir) { NativeCall<void, FVector*, FVector*, FVector*>(this, "APlayerController.GetAudioListenerPosition", OutLocation, OutFrontDir, OutRightDir); }

    FVector* GetFocalLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APlayerController.GetFocalLocation", result); }

    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); }

    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 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); }

    float GetInputAnalogKeyState(FKey Key) { return NativeCall<float, FKey>(this, "APlayerController.GetInputAnalogKeyState", Key); }

    float GetInputKeyTimeDown(FKey Key) { return NativeCall<float, FKey>(this, "APlayerController.GetInputKeyTimeDown", Key); }

    void GetInputMotionState(FVector* Tilt, FVector* RotationRate, FVector* Gravity, FVector* Acceleration) { NativeCall<void, FVector*, FVector*, FVector*, FVector*>(this, "APlayerController.GetInputMotionState", Tilt, RotationRate, Gravity, Acceleration); }

    void GetInputMouseDelta(float* DeltaX, float* DeltaY) { NativeCall<void, float*, float*>(this, "APlayerController.GetInputMouseDelta", DeltaX, DeltaY); }

    void GetInputTouchState(ETouchIndex::Type FingerIndex, float* LocationX, float* LocationY, bool* bIsCurrentlyPressed) { NativeCall<void, ETouchIndex::Type, float*, float*, bool*>(this, "APlayerController.GetInputTouchState", FingerIndex, LocationX, LocationY, bIsCurrentlyPressed); }

    FVector* GetInputVectorKeyState(FVector* result, FKey Key) { return NativeCall<FVector*, FVector*, FKey>(this, "APlayerController.GetInputVectorKeyState", result, Key); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "APlayerController.GetLifetimeReplicatedProps", OutLifetimeProps); }

    EMouseCursor::Type GetMouseCursor() { return NativeCall<EMouseCursor::Type>(this, "APlayerController.GetMouseCursor"); }

    bool GetMousePosition(float* LocationX, float* LocationY) { return NativeCall<bool, float*, float*>(this, "APlayerController.GetMousePosition", LocationX, LocationY); }

    UNetConnection* GetNetConnection() { return NativeCall<UNetConnection*>(this, "APlayerController.GetNetConnection"); }

    UPlayer* GetNetOwningPlayer() { return NativeCall<UPlayer*>(this, "APlayerController.GetNetOwningPlayer"); }

    float GetNetPriority(FVector* ViewPos, FVector* ViewDir, APlayerController* Viewer, UActorChannel* InChannel, float Time, bool bLowBandwidth) { return NativeCall<float, FVector*, FVector*, APlayerController*, UActorChannel*, float, bool>(this, "APlayerController.GetNetPriority", ViewPos, ViewDir, Viewer, InChannel, Time, bLowBandwidth); }

    APlayerState* GetNextViewablePlayer(int dir) { return NativeCall<APlayerState*, int>(this, "APlayerController.GetNextViewablePlayer", dir); }

    APawn* GetPawnOrSpectator() { return NativeCall<APawn*>(this, "APlayerController.GetPawnOrSpectator"); }

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

    void GetPlayerViewPoint(FVector* out_Location, FRotator* out_Rotation) { NativeCall<void, FVector*, FRotator*>(this, "APlayerController.GetPlayerViewPoint", out_Location, out_Rotation); }

    void GetSeamlessTravelActorList(bool bToEntry, TArray<AActor*>* ActorList) { NativeCall<void, bool, TArray<AActor*>*>(this, "APlayerController.GetSeamlessTravelActorList", bToEntry, ActorList); }

    int GetSplitscreenPlayerCount() { return NativeCall<int>(this, "APlayerController.GetSplitscreenPlayerCount"); }

    AActor* GetViewTarget() { return NativeCall<AActor*>(this, "APlayerController.GetViewTarget"); }

    void GetViewportSize(int* SizeX, int* SizeY) { NativeCall<void, int*, int*>(this, "APlayerController.GetViewportSize", SizeX, SizeY); }

    bool HasClientLoadedCurrentWorld() { return NativeCall<bool>(this, "APlayerController.HasClientLoadedCurrentWorld"); }

    void InitInputSystem() { NativeCall<void>(this, "APlayerController.InitInputSystem"); }

    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 InputKey(FKey Key, EInputEvent EventType, float AmountDepressed, bool bGamepad) { return NativeCall<bool, FKey, EInputEvent, float, bool>(this, "APlayerController.InputKey", Key, EventType, AmountDepressed, bGamepad); }

    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 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 IsFrozen() { return NativeCall<bool>(this, "APlayerController.IsFrozen"); }

    bool IsInputKeyDown(FKey Key) { return NativeCall<bool, FKey>(this, "APlayerController.IsInputKeyDown", Key); }

    bool ServerPause_Validate() { return NativeCall<bool>(this, "APlayerController.ServerPause_Validate"); }

    bool IsLookInputIgnored() { return NativeCall<bool>(this, "APlayerController.IsLookInputIgnored"); }

    bool IsMoveInputIgnored() { return NativeCall<bool>(this, "APlayerController.IsMoveInputIgnored"); }

    bool IsPaused() { return NativeCall<bool>(this, "APlayerController.IsPaused"); }

    bool IsPlayerMuted(FString* VivoxUsername) { return NativeCall<bool, FString*>(this, "APlayerController.IsPlayerMuted", VivoxUsername); }

    bool IsPlayerMuted(FUniqueNetId* PlayerId) { return NativeCall<bool, FUniqueNetId*>(this, "APlayerController.IsPlayerMuted", PlayerId); }

    bool IsPrimaryPlayer() { return NativeCall<bool>(this, "APlayerController.IsPrimaryPlayer"); }

    bool IsSplitscreenPlayer(int* OutSplitscreenPlayerIndex) { return NativeCall<bool, int*>(this, "APlayerController.IsSplitscreenPlayer", OutSplitscreenPlayerIndex); }

    void LocalTravel(FString* FURL) { NativeCall<void, FString*>(this, "APlayerController.LocalTravel", FURL); }

    bool NetConnectionHasActiveActor(AActor* AnActor) { return NativeCall<bool, AActor*>(this, "APlayerController.NetConnectionHasActiveActor", AnActor); }

    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 NotifyDirectorControl(bool bNowControlling, AMatineeActor* CurrentMatinee) { NativeCall<void, bool, AMatineeActor*>(this, "APlayerController.NotifyDirectorControl", bNowControlling, CurrentMatinee); }

    void NotifyLoadedWorld(FName WorldPackageName, bool bFinalDest) { NativeCall<void, FName, bool>(this, "APlayerController.NotifyLoadedWorld", WorldPackageName, bFinalDest); }

    bool NotifyServerReceivedClientData(APawn* InPawn, float TimeStamp) { return NativeCall<bool, APawn*, float>(this, "APlayerController.NotifyServerReceivedClientData", InPawn, TimeStamp); }

    void OnNetCleanup(UNetConnection* Connection) { NativeCall<void, UNetConnection*>(this, "APlayerController.OnNetCleanup", Connection); }

    void Pause() { NativeCall<void>(this, "APlayerController.Pause"); }

    void PawnLeavingGame() { NativeCall<void>(this, "APlayerController.PawnLeavingGame"); }

    void PlayerTick(float DeltaTime) { NativeCall<void, float>(this, "APlayerController.PlayerTick", DeltaTime); }

    void Possess(APawn* PawnToPossess) { NativeCall<void, APawn*>(this, "APlayerController.Possess", PawnToPossess); }

    void PostInitializeComponents() { NativeCall<void>(this, "APlayerController.PostInitializeComponents"); }

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

    void PostProcessInput(const float DeltaTime, const bool bGamePaused) { NativeCall<void, const float, const bool>(this, "APlayerController.PostProcessInput", DeltaTime, bGamePaused); }

    void ProcessForceFeedback(const float DeltaTime, const bool bGamePaused) { NativeCall<void, const float, const bool>(this, "APlayerController.ProcessForceFeedback", DeltaTime, bGamePaused); }

    void ProcessPlayerInput(const float DeltaTime, const bool bGamePaused) { NativeCall<void, const float, const bool>(this, "APlayerController.ProcessPlayerInput", DeltaTime, bGamePaused); }

    bool ProjectWorldLocationToScreen(FVector WorldLocation, FVector2D* ScreenLocation) { return NativeCall<bool, FVector, FVector2D*>(this, "APlayerController.ProjectWorldLocationToScreen", WorldLocation, ScreenLocation); }

    void ReceivedPlayer() { NativeCall<void>(this, "APlayerController.ReceivedPlayer"); }

    void ReceivedSpectatorClass(TSubclassOf<AGameMode> SpectatorClass) { NativeCall<void, TSubclassOf<AGameMode>>(this, "APlayerController.ReceivedSpectatorClass", SpectatorClass); }

    void Reset() { NativeCall<void>(this, "APlayerController.Reset"); }

    void ResetCameraMode() { NativeCall<void>(this, "APlayerController.ResetCameraMode"); }

    void ResetIgnoreInputFlags() { NativeCall<void>(this, "APlayerController.ResetIgnoreInputFlags"); }

    void RestartLevel() { NativeCall<void>(this, "APlayerController.RestartLevel"); }

    void SafeRetryClientRestart() { NativeCall<void>(this, "APlayerController.SafeRetryClientRestart"); }

    void SafeServerCheckClientPossession() { NativeCall<void>(this, "APlayerController.SafeServerCheckClientPossession"); }

    void SafeServerUpdateSpectatorState() { NativeCall<void>(this, "APlayerController.SafeServerUpdateSpectatorState"); }

    void SeamlessTravelFrom(APlayerController* OldPC) { NativeCall<void, APlayerController*>(this, "APlayerController.SeamlessTravelFrom", OldPC); }

    void SendClientAdjustment() { NativeCall<void>(this, "APlayerController.SendClientAdjustment"); }

    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 ServerCamera_Implementation(FName NewMode) { NativeCall<void, FName>(this, "APlayerController.ServerCamera_Implementation", NewMode); }

    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 ServerCheckClientPossession_Implementation() { NativeCall<void>(this, "APlayerController.ServerCheckClientPossession_Implementation"); }

    void ServerMutePlayer_Implementation(FUniqueNetIdRepl PlayerId) { NativeCall<void, FUniqueNetIdRepl>(this, "APlayerController.ServerMutePlayer_Implementation", PlayerId); }

    bool ServerMutePlayer_Validate(FUniqueNetIdRepl PlayerId) { return NativeCall<bool, FUniqueNetIdRepl>(this, "APlayerController.ServerMutePlayer_Validate", PlayerId); }

    void ServerNotifyLoadedWorld_Implementation(FName WorldPackageName) { NativeCall<void, FName>(this, "APlayerController.ServerNotifyLoadedWorld_Implementation", WorldPackageName); }

    bool ServerNotifyLoadedWorld_Validate(FName WorldPackageName) { return NativeCall<bool, FName>(this, "APlayerController.ServerNotifyLoadedWorld_Validate", WorldPackageName); }

    void ServerPause_Implementation() { NativeCall<void>(this, "APlayerController.ServerPause_Implementation"); }

    void ServerReceivedPlayerControllerAck_Implementation() { NativeCall<void>(this, "APlayerController.ServerReceivedPlayerControllerAck_Implementation"); }

    void ServerRestartPlayer_Implementation() { NativeCall<void>(this, "APlayerController.ServerRestartPlayer_Implementation"); }

    void ServerSetSpectatorLocation_Implementation(FVector NewLoc) { NativeCall<void, FVector>(this, "APlayerController.ServerSetSpectatorLocation_Implementation", NewLoc); }

    void ServerToggleAILogging_Implementation() { NativeCall<void>(this, "APlayerController.ServerToggleAILogging_Implementation"); }

    void ServerUnmutePlayer_Implementation(FUniqueNetIdRepl PlayerId) { NativeCall<void, FUniqueNetIdRepl>(this, "APlayerController.ServerUnmutePlayer_Implementation", PlayerId); }

    bool ServerUnmutePlayer_Validate(FUniqueNetIdRepl PlayerId) { return NativeCall<bool, FUniqueNetIdRepl>(this, "APlayerController.ServerUnmutePlayer_Validate", PlayerId); }

    void ServerUpdateCamera_Implementation(FVector_NetQuantize CamLoc, int CamPitchAndYaw) { NativeCall<void, FVector_NetQuantize, int>(this, "APlayerController.ServerUpdateCamera_Implementation", CamLoc, CamPitchAndYaw); }

    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); }

    void ServerVerifyViewTarget_Implementation() { NativeCall<void>(this, "APlayerController.ServerVerifyViewTarget_Implementation"); }

    void ServerViewNextPlayer_Implementation() { NativeCall<void>(this, "APlayerController.ServerViewNextPlayer_Implementation"); }

    void ServerViewPrevPlayer_Implementation() { NativeCall<void>(this, "APlayerController.ServerViewPrevPlayer_Implementation"); }

    void SetAudioListenerOverride(USceneComponent* AttachedComponent, FVector Location, FRotator Rotation) { NativeCall<void, USceneComponent*, FVector, FRotator>(this, "APlayerController.SetAudioListenerOverride", AttachedComponent, Location, Rotation); }

    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 SetCinematicMode(bool bInCinematicMode, bool bAffectsMovement, bool bAffectsTurning) { NativeCall<void, bool, bool, bool>(this, "APlayerController.SetCinematicMode", bInCinematicMode, bAffectsMovement, bAffectsTurning); }

    void SetIgnoreLookInput(bool bNewLookInput) { NativeCall<void, bool>(this, "APlayerController.SetIgnoreLookInput", bNewLookInput); }

    void SetIgnoreMoveInput(bool bNewMoveInput) { NativeCall<void, bool>(this, "APlayerController.SetIgnoreMoveInput", bNewMoveInput); }

    void SetInitialLocationAndRotation(FVector* NewLocation, FRotator* NewRotation) { NativeCall<void, FVector*, FRotator*>(this, "APlayerController.SetInitialLocationAndRotation", NewLocation, NewRotation); }

    void SetName(FString* S) { NativeCall<void, FString*>(this, "APlayerController.SetName", S); }

    void SetNetSpeed(int NewSpeed) { NativeCall<void, int>(this, "APlayerController.SetNetSpeed", NewSpeed); }

    void SetPawn(APawn* InPawn) { NativeCall<void, APawn*>(this, "APlayerController.SetPawn", InPawn); }

    void SetPlayer(UPlayer* InPlayer) { NativeCall<void, UPlayer*>(this, "APlayerController.SetPlayer", InPlayer); }

    void SetSpawnLocation(FVector* NewLocation) { NativeCall<void, FVector*>(this, "APlayerController.SetSpawnLocation", NewLocation); }

    void SetVirtualJoystickVisibility(bool bVisible) { NativeCall<void, bool>(this, "APlayerController.SetVirtualJoystickVisibility", bVisible); }

    void SetupInputComponent() { NativeCall<void>(this, "APlayerController.SetupInputComponent"); }

    bool ShouldReplicateVoicePacketFrom(FUniqueNetId* Sender, char ShouldUseSuperRange, char* PlaybackFlags) { return NativeCall<bool, FUniqueNetId*, char, char*>(this, "APlayerController.ShouldReplicateVoicePacketFrom", Sender, ShouldUseSuperRange, PlaybackFlags); }

    bool ShouldShowMouseCursor() { return NativeCall<bool>(this, "APlayerController.ShouldShowMouseCursor"); }

    void SmoothTargetViewRotation(APawn* TargetPawn, float DeltaSeconds) { NativeCall<void, APawn*, float>(this, "APlayerController.SmoothTargetViewRotation", TargetPawn, DeltaSeconds); }

    void SpawnDefaultHUD() { NativeCall<void>(this, "APlayerController.SpawnDefaultHUD"); }

    void SpawnHUD(TSubclassOf<AHUD> NewHUDClass) { NativeCall<void, TSubclassOf<AHUD>>(this, "APlayerController.SpawnHUD", NewHUDClass); }

    void SpawnPlayerCameraManager() { NativeCall<void>(this, "APlayerController.SpawnPlayerCameraManager"); }

    void StartFire(char FireModeNum) { NativeCall<void, char>(this, "APlayerController.StartFire", FireModeNum); }

    void StartSpectatingOnly() { NativeCall<void>(this, "APlayerController.StartSpectatingOnly"); }

    void StartTalking() { NativeCall<void>(this, "APlayerController.StartTalking"); }

    void StopTalking() { NativeCall<void>(this, "APlayerController.StopTalking"); }

    void SwitchLevel(FString* FURL) { NativeCall<void, FString*>(this, "APlayerController.SwitchLevel", FURL); }

    void TickPlayerInput(const float DeltaSeconds, const bool bGamePaused) { NativeCall<void, const float, const bool>(this, "APlayerController.TickPlayerInput", DeltaSeconds, bGamePaused); }

    void ToggleSpeaking(bool bSpeaking, bool bUseSuperRange) { NativeCall<void, bool, bool>(this, "APlayerController.ToggleSpeaking", bSpeaking, bUseSuperRange); }

    void UnPossess() { NativeCall<void>(this, "APlayerController.UnPossess"); }

    void UpdateCameraManager(float DeltaSeconds) { NativeCall<void, float>(this, "APlayerController.UpdateCameraManager", DeltaSeconds); }

    void UpdatePing(float InPing) { NativeCall<void, float>(this, "APlayerController.UpdatePing", InPing); }

    void UpdateRotation(float DeltaTime) { NativeCall<void, float>(this, "APlayerController.UpdateRotation", DeltaTime); }

    void UpdateStateInputComponents() { NativeCall<void>(this, "APlayerController.UpdateStateInputComponents"); }

    void ViewAPlayer(int dir) { NativeCall<void, int>(this, "APlayerController.ViewAPlayer", dir); }

    bool WasInputKeyJustPressed(FKey Key) { return NativeCall<bool, FKey>(this, "APlayerController.WasInputKeyJustPressed", Key); }

    bool WasInputKeyJustReleased(FKey Key) { return NativeCall<bool, FKey>(this, "APlayerController.WasInputKeyJustReleased", Key); }

    void ClientCapBandwidth(int Cap) { NativeCall<void, int>(this, "APlayerController.ClientCapBandwidth", Cap); }

    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 ClientGameEnded(AActor* EndGameFocus, bool bIsWinner) { NativeCall<void, AActor*, bool>(this, "APlayerController.ClientGameEnded", EndGameFocus, bIsWinner); }

    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 ClientNetGUIDActorDeletion(FNetworkGUID TheNetGUID) { NativeCall<void, FNetworkGUID>(this, "APlayerController.ClientNetGUIDActorDeletion", TheNetGUID); }

    void ClientNotifyReconnected(APawn* NewPawn) { NativeCall<void, APawn*>(this, "APlayerController.ClientNotifyReconnected", NewPawn); }

    void ClientNotifyRespawned(APawn* NewPawn, bool IsFirstSpawn) { NativeCall<void, APawn*, bool>(this, "APlayerController.ClientNotifyRespawned", NewPawn, IsFirstSpawn); }

    void ClientProcessNetExecCommand(AActor* ForActor, FName CommandName, FNetExecParams ExecParams) { NativeCall<void, AActor*, FName, FNetExecParams>(this, "APlayerController.ClientProcessNetExecCommand", ForActor, CommandName, ExecParams); }

    void ClientProcessNetExecCommandUnreliable(AActor* ForActor, FName CommandName, FNetExecParams ExecParams) { NativeCall<void, AActor*, FName, FNetExecParams>(this, "APlayerController.ClientProcessNetExecCommandUnreliable", ForActor, CommandName, ExecParams); }

    void ClientProcessSimpleNetExecCommandBP(AActor* ForActor, FName CommandName) { NativeCall<void, AActor*, FName>(this, "APlayerController.ClientProcessSimpleNetExecCommandBP", ForActor, CommandName); }

    void ClientProcessSimpleNetExecCommandUnreliableBP(AActor* ForActor, FName CommandName) { NativeCall<void, AActor*, FName>(this, "APlayerController.ClientProcessSimpleNetExecCommandUnreliableBP", ForActor, CommandName); }

    void ClientRepObjRef(UObject* Object) { NativeCall<void, UObject*>(this, "APlayerController.ClientRepObjRef", Object); }

    void ClientReset() { NativeCall<void>(this, "APlayerController.ClientReset"); }

    void ClientRestart(APawn* NewPawn) { NativeCall<void, APawn*>(this, "APlayerController.ClientRestart", NewPawn); }

    void ClientRetryClientRestart(APawn* NewPawn) { NativeCall<void, APawn*>(this, "APlayerController.ClientRetryClientRestart", NewPawn); }

    void ClientReturnToMainMenu(FString* ReturnReason) { NativeCall<void, FString*>(this, "APlayerController.ClientReturnToMainMenu", ReturnReason); }

    void ClientSetBlockOnAsyncLoading() { NativeCall<void>(this, "APlayerController.ClientSetBlockOnAsyncLoading"); }

    void ClientSetCameraFade(bool bEnableFading, FColor FadeColor, FVector2D FadeAlpha, float FadeTime, bool bFadeAudio) { NativeCall<void, bool, FColor, FVector2D, float, bool>(this, "APlayerController.ClientSetCameraFade", bEnableFading, FadeColor, FadeAlpha, FadeTime, bFadeAudio); }

    void ClientSetCinematicMode(bool bInCinematicMode, bool bAffectsMovement, bool bAffectsTurning, bool bAffectsHUD) { NativeCall<void, bool, bool, bool, bool>(this, "APlayerController.ClientSetCinematicMode", bInCinematicMode, bAffectsMovement, bAffectsTurning, bAffectsHUD); }

    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 ClientTeleportSucceeded(FVector TeleportLoc, FRotator TeleportRot, bool bSimpleTeleport) { NativeCall<void, FVector, FRotator, bool>(this, "APlayerController.ClientTeleportSucceeded", TeleportLoc, TeleportRot, bSimpleTeleport); }

    void ClientUnmutePlayer(FUniqueNetIdRepl PlayerId) { NativeCall<void, FUniqueNetIdRepl>(this, "APlayerController.ClientUnmutePlayer", PlayerId); }

    void ClientUpdateLevelStreamingStatus(FName PackageName, bool bNewShouldBeLoaded, bool bNewShouldBeVisible, bool bNewShouldBlockOnLoad, int LODIndex) { NativeCall<void, FName, bool, bool, bool, int>(this, "APlayerController.ClientUpdateLevelStreamingStatus", PackageName, bNewShouldBeLoaded, bNewShouldBeVisible, bNewShouldBlockOnLoad, LODIndex); }

    void ClientVoiceHandshakeComplete() { NativeCall<void>(this, "APlayerController.ClientVoiceHandshakeComplete"); }

    void ClientWasKicked(FText* KickReason) { NativeCall<void, FText*>(this, "APlayerController.ClientWasKicked", KickReason); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "APlayerController.GetPrivateStaticClass", Package); }

    void NetSpawnActorAtLocation(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", AnActorClass, AtLocation, AtRotation, attachToComponent, dataIndex, attachSocketName); }

    void ServerAcknowledgePossession(APawn* P) { NativeCall<void, APawn*>(this, "APlayerController.ServerAcknowledgePossession", P); }

    void ServerCamera(FName NewMode) { NativeCall<void, FName>(this, "APlayerController.ServerCamera", NewMode); }

    void ServerChangeName(FString* S) { NativeCall<void, FString*>(this, "APlayerController.ServerChangeName", S); }

    void ServerCheckClientPossession() { NativeCall<void>(this, "APlayerController.ServerCheckClientPossession"); }

    void ServerMutePlayer(FUniqueNetIdRepl PlayerId) { NativeCall<void, FUniqueNetIdRepl>(this, "APlayerController.ServerMutePlayer", PlayerId); }

    void ServerNotifyLoadedWorld(FName WorldPackageName) { NativeCall<void, FName>(this, "APlayerController.ServerNotifyLoadedWorld", WorldPackageName); }

    void ServerPause() { NativeCall<void>(this, "APlayerController.ServerPause"); }

    void ServerReceivedPlayerControllerAck() { NativeCall<void>(this, "APlayerController.ServerReceivedPlayerControllerAck"); }

    void ServerRestartPlayer() { NativeCall<void>(this, "APlayerController.ServerRestartPlayer"); }

    void ServerSetSpectatorLocation(FVector NewLoc) { NativeCall<void, FVector>(this, "APlayerController.ServerSetSpectatorLocation", NewLoc); }

    void ServerShortTimeout() { NativeCall<void>(this, "APlayerController.ServerShortTimeout"); }

    void ServerUnmutePlayer(FUniqueNetIdRepl PlayerId) { NativeCall<void, FUniqueNetIdRepl>(this, "APlayerController.ServerUnmutePlayer", PlayerId); }

    void ServerUpdateLevelVisibility(FName PackageName, bool bIsVisible) { NativeCall<void, FName, bool>(this, "APlayerController.ServerUpdateLevelVisibility", PackageName, bIsVisible); }

    void ServerVerifyViewTarget() { NativeCall<void>(this, "APlayerController.ServerVerifyViewTarget"); }

    void ServerViewNextPlayer() { NativeCall<void>(this, "APlayerController.ServerViewNextPlayer"); }

    static void StaticRegisterNativesAPlayerController() { NativeCall<void>(nullptr, "APlayerController.StaticRegisterNativesAPlayerController"); }

};


struct AShooterPlayerController : APlayerController

{

    FieldArray<char, 10> HeldFeatKeyField() { return { this, "AShooterPlayerController.HeldFeatKey" }; }

    FieldArray<long double, 10> HeldFeatKeyTimeField() { return { this, "AShooterPlayerController.HeldFeatKeyTime" }; }

    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" }; }

    int& MaxMapMarkersField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.MaxMapMarkers"); }

    bool& bChangeingServerCoordsField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bChangeingServerCoords"); }

    FString& ChangeingServerCoordsMessageField() { return *GetNativePointerField<FString*>(this, "AShooterPlayerController.ChangeingServerCoordsMessage"); }

    TArray<TSubclassOf<UPrimalEngramEntry>>& UnlockedSkillsField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalEngramEntry>>*>(this, "AShooterPlayerController.UnlockedSkills"); }

    FPrimalPlayerDataStruct* MyPlayerDataStructField() { return GetNativePointerField<FPrimalPlayerDataStruct*>(this, "AShooterPlayerController.MyPlayerDataStruct"); }

    bool& bGPSZoomOutField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bGPSZoomOut"); }

    bool& bGPSZoomInField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bGPSZoomIn"); }

    FVector& CurrentPlayerCharacterLocationField() { return *GetNativePointerField<FVector*>(this, "AShooterPlayerController.CurrentPlayerCharacterLocation"); }

    int& ModifedButtonCountField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.ModifedButtonCount"); }

    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"); }

    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"); }

    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"); }

    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<APrimalStructureBed>& SpawnAtBedField() { return *GetNativePointerField<TWeakObjectPtr<APrimalStructureBed>*>(this, "AShooterPlayerController.SpawnAtBed"); }

    APawn* TempLastLostPawnField() { return *GetNativePointerField<APawn**>(this, "AShooterPlayerController.TempLastLostPawn"); }

    bool& bLockedInputDontRecenterMouseField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bLockedInputDontRecenterMouse"); }

    long double& LastRespawnTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastRespawnTime"); }

    bool& bIsFirstSpawnField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bIsFirstSpawn"); }

    bool& bIsRespawningField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bIsRespawning"); }

    bool& bIsVRPlayerField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bIsVRPlayer"); }

    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"); }

    long double& LastTimePlayerRotationInputField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastTimePlayerRotationInput"); }

    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& bServerRefreshStatusField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bServerRefreshStatus"); }

    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"); }

    bool& bServerIsPaintingField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bServerIsPainting"); }

    bool& bServerPaintingSuccessField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bServerPaintingSuccess"); }

    float& TotalTimeOnLandField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.TotalTimeOnLand"); }

    long double& LastTimePlayedSetSailMusicField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastTimePlayedSetSailMusic"); }

    long double& LastPlayedSetSailStingerTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastPlayedSetSailStingerTime"); }

    float& LandIntervalForSetSailStingerField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.LandIntervalForSetSailStinger"); }

    float& MinimumIntervalBetweenSetSailStingersField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.MinimumIntervalBetweenSetSailStingers"); }

    long double& LastListenServerNotifyOutOfRangeTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastListenServerNotifyOutOfRangeTime"); }

    int& SpectatorCycleIndexField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.SpectatorCycleIndex"); }

    TEnumAsByte<enum EFastTravelType>& CurrentFastTravelTypeField() { return *GetNativePointerField<TEnumAsByte<enum EFastTravelType>*>(this, "AShooterPlayerController.CurrentFastTravelType"); }

    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& bCommunicationPrivilegeFetchedField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bCommunicationPrivilegeFetched"); }

    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"); }

    bool& bFullyAuthenticatedField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bFullyAuthenticated"); }

    bool& bNotificationSettingsReceivedField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bNotificationSettingsReceived"); }

    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<FTribeLogEntry>& CurrentTribeLogField() { return *GetNativePointerField<TArray<FTribeLogEntry>*>(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"); }

    bool& bTraveledSeamlesslyField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bTraveledSeamlessly"); }

    float& LastSeamlessTravelTimeField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.LastSeamlessTravelTime"); }

    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& HitMarkerScaleMultiplierField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.HitMarkerScaleMultiplier"); }

    bool& bHitMarkerWasMeleeHitField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bHitMarkerWasMeleeHit"); }

    float& DoFSettingCurrentTimerField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.DoFSettingCurrentTimer"); }

    float& DoFSettingTargetTimerField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.DoFSettingTargetTimer"); }

    int& LastSpawnPointIDField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.LastSpawnPointID"); }

    int& LastSpawnRegionIndexField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.LastSpawnRegionIndex"); }

    bool& bReceivedSubscribedAppsField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bReceivedSubscribedApps"); }

    long double& PossessedFirstPawnTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.PossessedFirstPawnTime"); }

    long double& LastPinRequestTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastPinRequestTime"); }

    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"); }

    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"); }

    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"); }

    FPrimalStats& PrimalStatsCacheField() { return *GetNativePointerField<FPrimalStats*>(this, "AShooterPlayerController.PrimalStatsCache"); }

    bool& bLocalCameraInVacuumSealedContainerOrRaftField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bLocalCameraInVacuumSealedContainerOrRaft"); }

    FAttachmentPoint& LastCycledSnapPointField() { return *GetNativePointerField<FAttachmentPoint*>(this, "AShooterPlayerController.LastCycledSnapPoint"); }

    TArray<FAttachmentPoint>& LastCycledSnapPointsField() { return *GetNativePointerField<TArray<FAttachmentPoint>*>(this, "AShooterPlayerController.LastCycledSnapPoints"); }

    bool& bResetSnapPointField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bResetSnapPoint"); }

    bool& bNetIsCurrentlyFirstPersonField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bNetIsCurrentlyFirstPerson"); }

    bool& bLastSentNetIsCurrentlyFirstPersonField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bLastSentNetIsCurrentlyFirstPerson"); }

    TArray<FName>& AllowedBindingsInTransitionField() { return *GetNativePointerField<TArray<FName>*>(this, "AShooterPlayerController.AllowedBindingsInTransition"); }

    bool& bRequestingFirstHomeServerField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bRequestingFirstHomeServer"); }

    FString& LastPlayerFirstHomeServerIdStrField() { return *GetNativePointerField<FString*>(this, "AShooterPlayerController.LastPlayerFirstHomeServerIdStr"); }

    bool& bIsQueryingCurrentServerIdField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bIsQueryingCurrentServerId"); }

    float& DistanceToDisplayTreasureField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.DistanceToDisplayTreasure"); }

    float& DistanceToCollectTreasureField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.DistanceToCollectTreasure"); }

    bool& bIsAltHeldField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bIsAltHeld"); }

    bool& bIsRightShoulderHeldField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bIsRightShoulderHeld"); }

    TArray<FShownTreasureData>& ShownTreasuresField() { return *GetNativePointerField<TArray<FShownTreasureData>*>(this, "AShooterPlayerController.ShownTreasures"); }

    long double& JoinedAtField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.JoinedAt"); }

    long double& OverSubscriptionHandingAtField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.OverSubscriptionHandingAt"); }

    long double& TimeOfLastMapPressField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.TimeOfLastMapPress"); }

    int& LastTutorialHintTextFrameField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.LastTutorialHintTextFrame"); }

    FString& LastTutorialHintTextField() { return *GetNativePointerField<FString*>(this, "AShooterPlayerController.LastTutorialHintText"); }

    long double& ClientLastStartedFastTravelTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ClientLastStartedFastTravelTime"); }

    unsigned int& HomeServerIdField() { return *GetNativePointerField<unsigned int*>(this, "AShooterPlayerController.HomeServerId"); }

    UStaticMesh* LightingCheckerMeshField() { return *GetNativePointerField<UStaticMesh**>(this, "AShooterPlayerController.LightingCheckerMesh"); }

    UMaterial* LightingCheckerMaterialField() { return *GetNativePointerField<UMaterial**>(this, "AShooterPlayerController.LightingCheckerMaterial"); }

    FVector& LightingCheckerScaleField() { return *GetNativePointerField<FVector*>(this, "AShooterPlayerController.LightingCheckerScale"); }

    bool& bAdminPreventFastClaimingField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bAdminPreventFastClaiming"); }

    bool& bIsOnlyViewingRemoteInventoryField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bIsOnlyViewingRemoteInventory"); }

    bool& bHasViewOnlyInventoryOpenField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bHasViewOnlyInventoryOpen"); }

    bool& bRemovePlayerDataOnSeamlessTravelField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bRemovePlayerDataOnSeamlessTravel"); }

    int& ClientLastRequestFullMapEntitiesChangeIDField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.ClientLastRequestFullMapEntitiesChangeID"); }

    int& ClientLastRequestFullMapEntitiesCountField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.ClientLastRequestFullMapEntitiesCount"); }

    int& PreviousTribeEntitiesRequestedTargetingTeamField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.PreviousTribeEntitiesRequestedTargetingTeam"); }

    long double& ClientLastRefreshNeedingMapEntitiesTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.ClientLastRefreshNeedingMapEntitiesTime"); }

    long double& LastTimeTribeEntitiesRequestedField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastTimeTribeEntitiesRequested"); }

    bool& bClientIsReceivingMapEntitiesField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bClientIsReceivingMapEntities"); }

    TArray<FTribeEntity>& LocalCachedMapEntitiesField() { return *GetNativePointerField<TArray<FTribeEntity>*>(this, "AShooterPlayerController.LocalCachedMapEntities"); }

    float& ClientLastRequestedTribeDataTimeField() { return *GetNativePointerField<float*>(this, "AShooterPlayerController.ClientLastRequestedTribeDataTime"); }

    bool& bClientTribeDataDirtyField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bClientTribeDataDirty"); }

    int& LastTribeDataChangeCountField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.LastTribeDataChangeCount"); }

    int& LastTribeMemberDataChangeCountField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.LastTribeMemberDataChangeCount"); }

    int& LastTribeRankGroupRequestChangeCountField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.LastTribeRankGroupRequestChangeCount"); }

    int& ClientCurrentTribeGroupRankIndexField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.ClientCurrentTribeGroupRankIndex"); }

    int& TribeDataChangeCountField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.TribeDataChangeCount"); }

    int& LastTribeMembersLastOnlineChangeCountField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.LastTribeMembersLastOnlineChangeCount"); }

    long double& LastTribeMembersPresenceRequestTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastTribeMembersPresenceRequestTime"); }

    int& LastIslandInfoVersionField() { return *GetNativePointerField<int*>(this, "AShooterPlayerController.LastIslandInfoVersion"); }

    bool& bForceTeleportClientToHostField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bForceTeleportClientToHost"); }

    TArray<FChatMessage*> MessageQueueField() { return *GetNativePointerField<TArray<FChatMessage*>*>(this, "AShooterPlayerController.MessageQueue"); }

    bool& bPendingServerCheckField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bPendingServerCheck"); }

    bool& bServerAllowCommunicationField() { return *GetNativePointerField<bool*>(this, "AShooterPlayerController.bServerAllowCommunication"); }

    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"); }

    long double& LastVivoxPositionalUpdateField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerController.LastVivoxPositionalUpdate"); }


    // Bit fields


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

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

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

    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> bGamepadSpecialAttackHeld() { return { this, "AShooterPlayerController.bGamepadSpecialAttackHeld" }; }

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

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

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

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

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

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

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


    // Functions


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

    void AcknowledgePossession(APawn* P) { NativeCall<void, APawn*>(this, "AShooterPlayerController.AcknowledgePossession", P); }

    void ActivateMultiUseSelection(bool bIsFromUseRelease) { NativeCall<void, bool>(this, "AShooterPlayerController.ActivateMultiUseSelection", bIsFromUseRelease); }

    void AddExperience(float HowMuch, bool fromTribeShare, bool bPreventSharingWithTribe) { NativeCall<void, float, bool, bool>(this, "AShooterPlayerController.AddExperience", HowMuch, fromTribeShare, bPreventSharingWithTribe); }

    void AdminCheat(FString* Msg) { NativeCall<void, FString*>(this, "AShooterPlayerController.AdminCheat", Msg); }

    void AllowPlayerToJoinNoCheck(FString* PlayerId) { NativeCall<void, FString*>(this, "AShooterPlayerController.AllowPlayerToJoinNoCheck", PlayerId); }

    bool AllowTribeGroupPermission(ETribeGroupPermission::Type TribeGroupPermission, UObject* OnObject) { return NativeCall<bool, ETribeGroupPermission::Type, UObject*>(this, "AShooterPlayerController.AllowTribeGroupPermission", TribeGroupPermission, OnObject); }

    void ApplyDepthOfFieldSetting(int Index, float CurrentTimer) { NativeCall<void, int, float>(this, "AShooterPlayerController.ApplyDepthOfFieldSetting", Index, CurrentTimer); }

    void AsyncQueryAndProcessCurrentServerIdSpawning() { NativeCall<void>(this, "AShooterPlayerController.AsyncQueryAndProcessCurrentServerIdSpawning"); }

    void AutoCycle(float Duration) { NativeCall<void, float>(this, "AShooterPlayerController.AutoCycle", Duration); }

    void BPClientNotifyEditText(TSubclassOf<UObject> ForObjectClass, int ExtraID1, int ExtraID2, UObject* ForObject) { NativeCall<void, TSubclassOf<UObject>, int, int, UObject*>(this, "AShooterPlayerController.BPClientNotifyEditText", ForObjectClass, ExtraID1, ExtraID2, ForObject); }

    void BPGetAimedUseActor(AActor** AimedUseActor, UActorComponent** AimedUseComponent, int* HitBoxIndex) { NativeCall<void, AActor**, UActorComponent**, int*>(this, "AShooterPlayerController.BPGetAimedUseActor", AimedUseActor, AimedUseComponent, HitBoxIndex); }

    void BPGetPlayerViewPoint(FVector* out_Location, FRotator* out_Rotation) { NativeCall<void, FVector*, FRotator*>(this, "AShooterPlayerController.BPGetPlayerViewPoint", out_Location, out_Rotation); }

    void BanPlayer(FString PlayerSteamName) { NativeCall<void, FString>(this, "AShooterPlayerController.BanPlayer", PlayerSteamName); }

    AActor* BaseGetPlayerCharacter() { return NativeCall<AActor*>(this, "AShooterPlayerController.BaseGetPlayerCharacter"); }

    void BeginInactiveState() { NativeCall<void>(this, "AShooterPlayerController.BeginInactiveState"); }

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

    void BeginSpectatingState() { NativeCall<void>(this, "AShooterPlayerController.BeginSpectatingState"); }

    void CCC() { NativeCall<void>(this, "AShooterPlayerController.CCC"); }

    bool CanCommunicateVoiceWithRadio(AShooterPlayerController* otherPC) { return NativeCall<bool, AShooterPlayerController*>(this, "AShooterPlayerController.CanCommunicateVoiceWithRadio", otherPC); }

    bool CanDispatchInputDelegate(FName BindingName, TEnumAsByte<enum EInputEvent> KeyEvent) { return NativeCall<bool, FName, TEnumAsByte<enum EInputEvent>>(this, "AShooterPlayerController.CanDispatchInputDelegate", BindingName, KeyEvent); }

    bool CanDoPlayerCharacterInput(bool bIgnoreCurrentWeapon, bool bWeaponForcesMountedWeaponry) { return NativeCall<bool, bool, bool>(this, "AShooterPlayerController.CanDoPlayerCharacterInput", bIgnoreCurrentWeapon, bWeaponForcesMountedWeaponry); }

    bool CanRespec() { return NativeCall<bool>(this, "AShooterPlayerController.CanRespec"); }

    void CancelMultiUseSelection() { NativeCall<void>(this, "AShooterPlayerController.CancelMultiUseSelection"); }

    void ChangeState(FName NewState) { NativeCall<void, FName>(this, "AShooterPlayerController.ChangeState", NewState); }

    void Cheat(FString* Msg) { NativeCall<void, FString*>(this, "AShooterPlayerController.Cheat", Msg); }

    void CheckCheatsPassword_Implementation(FString* Pass) { NativeCall<void, FString*>(this, "AShooterPlayerController.CheckCheatsPassword_Implementation", Pass); }

    void CheckForPlayerInventory() { NativeCall<void>(this, "AShooterPlayerController.CheckForPlayerInventory"); }

    void CheckRequestSpectator_Implementation(FString* InSpectatorPass) { NativeCall<void, FString*>(this, "AShooterPlayerController.CheckRequestSpectator_Implementation", InSpectatorPass); }

    void CheckToOpenMapAllTimer() { NativeCall<void>(this, "AShooterPlayerController.CheckToOpenMapAllTimer"); }

    void CheckToOpenMapOnlyTimer() { NativeCall<void>(this, "AShooterPlayerController.CheckToOpenMapOnlyTimer"); }

    void CheckforOrbiting() { NativeCall<void>(this, "AShooterPlayerController.CheckforOrbiting"); }

    bool CheckforOrbitingInstantaneously() { return NativeCall<bool>(this, "AShooterPlayerController.CheckforOrbitingInstantaneously"); }

    void ClearTutorials() { NativeCall<void>(this, "AShooterPlayerController.ClearTutorials"); }

    void ClientAbortTravel_Implementation(unsigned int ServerID, unsigned __int64 ServerSteamId) { NativeCall<void, unsigned int, unsigned __int64>(this, "AShooterPlayerController.ClientAbortTravel_Implementation", ServerID, ServerSteamId); }

    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 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 ClientAddFloatingDamageText_Implementation(FVector_NetQuantize AtLocation, int DamageAmount, int FromTeamID, bool bForceText) { NativeCall<void, FVector_NetQuantize, int, int, bool>(this, "AShooterPlayerController.ClientAddFloatingDamageText_Implementation", AtLocation, DamageAmount, FromTeamID, bForceText); }

    void ClientAddFloatingText_Implementation(FVector_NetQuantize AtLocation, FString* FloatingTextString, FColor FloatingTextColor, float ScaleX, float ScaleY, float TextLifeSpan, FVector TextVelocity, float MinScale, float FadeInTime, float FadeOutTime, bool bForce) { NativeCall<void, FVector_NetQuantize, FString*, FColor, float, float, float, FVector, float, float, float, bool>(this, "AShooterPlayerController.ClientAddFloatingText_Implementation", AtLocation, FloatingTextString, FloatingTextColor, ScaleX, ScaleY, TextLifeSpan, TextVelocity, MinScale, FadeInTime, FadeOutTime, bForce); }

    void ClientAddFolderToInventoryComponent_Implementation(UPrimalInventoryComponent* forInventory, FString* NewCustomFolderName, int InventoryCompType) { NativeCall<void, UPrimalInventoryComponent*, FString*, int>(this, "AShooterPlayerController.ClientAddFolderToInventoryComponent_Implementation", forInventory, NewCustomFolderName, InventoryCompType); }

    void ClientAfterServerChange_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientAfterServerChange_Implementation"); }

    void ClientBeforeServerChange_Implementation(FString* Message) { NativeCall<void, FString*>(this, "AShooterPlayerController.ClientBeforeServerChange_Implementation", Message); }

    void ClientChatMessage_Implementation(FChatMessage Chat) { NativeCall<void, FChatMessage>(this, "AShooterPlayerController.ClientChatMessage_Implementation", Chat); }

    void ClientCollectedAchievementItem_Implementation(TSubclassOf<UPrimalItem> ItemClass) { NativeCall<void, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerController.ClientCollectedAchievementItem_Implementation", ItemClass); }

    void ClientDoMultiUse_Implementation(UObject* ForObject, int useIndex) { NativeCall<void, UObject*, int>(this, "AShooterPlayerController.ClientDoMultiUse_Implementation", ForObject, useIndex); }

    void ClientDrawDebugSphere_Implementation(TArray<FVector>* Locs, float Radius, int Segments, FColor DrawColor) { NativeCall<void, TArray<FVector>*, float, int, FColor>(this, "AShooterPlayerController.ClientDrawDebugSphere_Implementation", Locs, Radius, Segments, DrawColor); }

    void ClientEndReceivingTribeLog_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientEndReceivingTribeLog_Implementation"); }

    void ClientFailedRemoveSaddle_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientFailedRemoveSaddle_Implementation"); }

    void ClientFailedToAddItemFromArkInventory_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientFailedToAddItemFromArkInventory_Implementation"); }

    void ClientFeatActivationResult_Implementation(TSubclassOf<APrimalBuff> FeatClass, int ActivationResult) { NativeCall<void, TSubclassOf<APrimalBuff>, int>(this, "AShooterPlayerController.ClientFeatActivationResult_Implementation", FeatClass, ActivationResult); }

    void ClientFinishedReceivingActorItems_Implementation(UPrimalInventoryComponent* forInventory, bool bEquippedItems) { NativeCall<void, UPrimalInventoryComponent*, bool>(this, "AShooterPlayerController.ClientFinishedReceivingActorItems_Implementation", forInventory, bEquippedItems); }

    void ClientFinishedUseSlotTimeRemaining_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ClientFinishedUseSlotTimeRemaining_Implementation", forInventory, itemID); }

    void ClientForceCacheTattooPainting_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientForceCacheTattooPainting_Implementation"); }

    void ClientGetMessageOfTheDay_Implementation(FString* Message) { NativeCall<void, FString*>(this, "AShooterPlayerController.ClientGetMessageOfTheDay_Implementation", Message); }

    void ClientGiveFOW_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientGiveFOW_Implementation"); }

    void ClientGotoMainMenuListSessions_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientGotoMainMenuListSessions_Implementation"); }

    void ClientHUDNotificationTypeParams_Implementation(int MessageType, int MessageParam1, int MessageParam2, UObject* ObjectParam1, FString* StringParam1, float floatParam1) { NativeCall<void, int, int, int, UObject*, FString*, float>(this, "AShooterPlayerController.ClientHUDNotificationTypeParams_Implementation", MessageType, MessageParam1, MessageParam2, ObjectParam1, StringParam1, floatParam1); }

    void ClientInformHomeServerFull_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientInformHomeServerFull_Implementation"); }

    void ClientInformNeedsNewHomeServer_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientInformNeedsNewHomeServer_Implementation"); }

    void ClientInitHUDScenes_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientInitHUDScenes_Implementation"); }

    void ClientInsertActorItem_Implementation(UPrimalInventoryComponent* forInventory, FItemNetInfo itemInfo, FItemNetID InsertAfterItemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetInfo, FItemNetID>(this, "AShooterPlayerController.ClientInsertActorItem_Implementation", forInventory, itemInfo, InsertAfterItemID); }

    void ClientJoinVivoxChannel_Implementation(FString* JoinChannelVAT, 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", JoinChannelVAT, ChannelName, AtlasVoiceChannelTypeAsInt, AttenuationModelAsInt32, MaxDistance, MinDistance, Rolloff); }

    void ClientLoginToVivox_Implementation(FString* LoginVAT, FString* VivoxUsername) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ClientLoginToVivox_Implementation", LoginVAT, VivoxUsername); }

    void ClientMarkSeamlessActors_Implementation(TArray<AActor*>* ActorsWhichWillTravelSeamlessly, unsigned int DestServerId, EFastTravelType FastTravelType, float GridTravelToPosX, float GridTravelToPosY, float GridTravelToPosZ) { NativeCall<void, TArray<AActor*>*, unsigned int, EFastTravelType, float, float, float>(this, "AShooterPlayerController.ClientMarkSeamlessActors_Implementation", ActorsWhichWillTravelSeamlessly, DestServerId, FastTravelType, GridTravelToPosX, GridTravelToPosY, GridTravelToPosZ); }

    void ClientNetReceiveMapEntities_Implementation(TArray<FTribeEntity>* TribeEntities) { NativeCall<void, TArray<FTribeEntity>*>(this, "AShooterPlayerController.ClientNetReceiveMapEntities_Implementation", TribeEntities); }

    void ClientNetReceiveTribeMembersFinished_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientNetReceiveTribeMembersFinished_Implementation"); }

    void ClientNetReceiveTribeMembersLastOnlineAt_Implementation(TArray<unsigned int>* MembersLastOnlineAt) { NativeCall<void, TArray<unsigned int>*>(this, "AShooterPlayerController.ClientNetReceiveTribeMembersLastOnlineAt_Implementation", MembersLastOnlineAt); }

    void ClientNetReceiveTribeMembersPlayerDataID_Implementation(TArray<unsigned int>* MembersPlayerDataID) { NativeCall<void, TArray<unsigned int>*>(this, "AShooterPlayerController.ClientNetReceiveTribeMembersPlayerDataID_Implementation", MembersPlayerDataID); }

    void ClientNetReceiveTribeMembersPlayerName_Implementation(TArray<FString>* MembersPlayerName) { NativeCall<void, TArray<FString>*>(this, "AShooterPlayerController.ClientNetReceiveTribeMembersPlayerName_Implementation", MembersPlayerName); }

    void ClientNetReceiveTribeMembersRankGroupId_Implementation(TArray<int>* MembersRankGroupId) { NativeCall<void, TArray<int>*>(this, "AShooterPlayerController.ClientNetReceiveTribeMembersRankGroupId_Implementation", MembersRankGroupId); }

    void ClientNetReceiveTribeTribeAdmins_Implementation(TArray<unsigned int>* TribeAdmins) { NativeCall<void, TArray<unsigned int>*>(this, "AShooterPlayerController.ClientNetReceiveTribeTribeAdmins_Implementation", TribeAdmins); }

    void ClientNetStartReceivingMapEntities_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientNetStartReceivingMapEntities_Implementation"); }

    void ClientNetStopReceivingMapEntities_Implementation(int ServerMapEntitiesChangeID) { NativeCall<void, int>(this, "AShooterPlayerController.ClientNetStopReceivingMapEntities_Implementation", ServerMapEntitiesChangeID); }

    void ClientNotifyAdmin_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyAdmin_Implementation"); }

    void ClientNotifyCantHarvest_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyCantHarvest_Implementation"); }

    void ClientNotifyCantHitHarvest_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyCantHitHarvest_Implementation"); }

    void ClientNotifyDefeatedDino_Implementation(TSubclassOf<APrimalDinoCharacter> DinoClass) { NativeCall<void, TSubclassOf<APrimalDinoCharacter>>(this, "AShooterPlayerController.ClientNotifyDefeatedDino_Implementation", DinoClass); }

    void ClientNotifyDinoDeath_Implementation(FString* DinoName, FString* AttackerName, TSubclassOf<APrimalDinoCharacter> DinoClass) { NativeCall<void, FString*, FString*, TSubclassOf<APrimalDinoCharacter>>(this, "AShooterPlayerController.ClientNotifyDinoDeath_Implementation", DinoName, AttackerName, DinoClass); }

    void ClientNotifyDinoKill_Implementation(APrimalDinoCharacter* InstigatingPawn, APawn* VictimPawn) { NativeCall<void, APrimalDinoCharacter*, APawn*>(this, "AShooterPlayerController.ClientNotifyDinoKill_Implementation", InstigatingPawn, VictimPawn); }

    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 ClientNotifyHitHarvest_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyHitHarvest_Implementation"); }

    void ClientNotifyLevelUp_Implementation(APrimalCharacter* ForChar, int NewLevel) { NativeCall<void, APrimalCharacter*, int>(this, "AShooterPlayerController.ClientNotifyLevelUp_Implementation", ForChar, NewLevel); }

    void ClientNotifyListenServerOutOfRange_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyListenServerOutOfRange_Implementation"); }

    void ClientNotifyMessageOfTheDay_Implementation(FString* Message, float TimeToDisplay) { NativeCall<void, FString*, float>(this, "AShooterPlayerController.ClientNotifyMessageOfTheDay_Implementation", Message, TimeToDisplay); }

    void ClientNotifyPaintFinished_Implementation(bool bSuccess) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientNotifyPaintFinished_Implementation", bSuccess); }

    void ClientNotifyPlayerDeathReason_Implementation(FString* ReasonString) { NativeCall<void, FString*>(this, "AShooterPlayerController.ClientNotifyPlayerDeathReason_Implementation", ReasonString); }

    void ClientNotifyPlayerDeath_Implementation(APawn* InstigatingPawn, AActor* DamageCauser) { NativeCall<void, APawn*, AActor*>(this, "AShooterPlayerController.ClientNotifyPlayerDeath_Implementation", InstigatingPawn, DamageCauser); }

    void ClientNotifyPlayerKill_Implementation(AActor* PlayerPawn, APawn* VictimPawn) { NativeCall<void, AActor*, APawn*>(this, "AShooterPlayerController.ClientNotifyPlayerKill_Implementation", PlayerPawn, VictimPawn); }

    void ClientNotifyReconnected_Implementation(APawn* NewPawn) { NativeCall<void, APawn*>(this, "AShooterPlayerController.ClientNotifyReconnected_Implementation", NewPawn); }

    void ClientNotifyRemotePlayerDeath_Implementation(FString* PlayerName, FString* AttackerName) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ClientNotifyRemotePlayerDeath_Implementation", PlayerName, AttackerName); }

    void ClientNotifyRespawned_Implementation(APawn* NewPawn, bool IsFirstSpawn) { NativeCall<void, APawn*, bool>(this, "AShooterPlayerController.ClientNotifyRespawned_Implementation", NewPawn, IsFirstSpawn); }

    void ClientNotifySummonedDino_Implementation(TSubclassOf<APrimalDinoCharacter> DinoClass) { NativeCall<void, TSubclassOf<APrimalDinoCharacter>>(this, "AShooterPlayerController.ClientNotifySummonedDino_Implementation", DinoClass); }

    void ClientNotifyTamedDino_Implementation(TSubclassOf<APrimalDinoCharacter> DinoClass, FString* NameOveride, int Level) { NativeCall<void, TSubclassOf<APrimalDinoCharacter>, FString*, int>(this, "AShooterPlayerController.ClientNotifyTamedDino_Implementation", DinoClass, NameOveride, Level); }

    void ClientNotifyTorpidityIncrease_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyTorpidityIncrease_Implementation"); }

    void ClientNotifyTribeDataUpdated_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyTribeDataUpdated_Implementation"); }

    void ClientNotifyTribeXP_Implementation(float HowMuch) { NativeCall<void, float>(this, "AShooterPlayerController.ClientNotifyTribeXP_Implementation", HowMuch); }

    void ClientNotifyUnlockHairStyleOrEmote_Implementation(FName HairstyleOrEmoteName) { NativeCall<void, FName>(this, "AShooterPlayerController.ClientNotifyUnlockHairStyleOrEmote_Implementation", HairstyleOrEmoteName); }

    void ClientNotifyUnlockedEngram_Implementation(TSubclassOf<UPrimalEngramEntry> ItemClass) { NativeCall<void, TSubclassOf<UPrimalEngramEntry>>(this, "AShooterPlayerController.ClientNotifyUnlockedEngram_Implementation", ItemClass); }

    void ClientNotifyUpgradedItem_Implementation(UPrimalItem* UpgradedItem) { NativeCall<void, UPrimalItem*>(this, "AShooterPlayerController.ClientNotifyUpgradedItem_Implementation", UpgradedItem); }

    void ClientOnFastTravelFailed_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientOnFastTravelFailed_Implementation"); }

    void ClientOnReceivedCaptainOrder_Implementation(ECaptainOrder::Type ReceivedOrder, FVector TargetLocation, bool bIsFromCaptain) { NativeCall<void, ECaptainOrder::Type, FVector, bool>(this, "AShooterPlayerController.ClientOnReceivedCaptainOrder_Implementation", ReceivedOrder, TargetLocation, bIsFromCaptain); }

    void ClientPlayLocalSound_Implementation(USoundBase* aSound, bool bAttach) { NativeCall<void, USoundBase*, bool>(this, "AShooterPlayerController.ClientPlayLocalSound_Implementation", aSound, bAttach); }

    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 ClientReceiveMyTribeOnlineList_Implementation(TArray<unsigned int>* OnlinePlayerIDs) { NativeCall<void, TArray<unsigned int>*>(this, "AShooterPlayerController.ClientReceiveMyTribeOnlineList_Implementation", OnlinePlayerIDs); }

    void ClientReceiveOriginalHairColor_Implementation(FLinearColor HairColor) { NativeCall<void, FLinearColor>(this, "AShooterPlayerController.ClientReceiveOriginalHairColor_Implementation", HairColor); }

    void ClientReceiveStructureCraftingStatItem_Implementation(APrimalStructure* ForStructure, FItemNetInfo ItemInfo) { NativeCall<void, APrimalStructure*, FItemNetInfo>(this, "AShooterPlayerController.ClientReceiveStructureCraftingStatItem_Implementation", ForStructure, ItemInfo); }

    void ClientReceiveTribeRankGroup_Implementation(int GroupRankIndex) { NativeCall<void, int>(this, "AShooterPlayerController.ClientReceiveTribeRankGroup_Implementation", GroupRankIndex); }

    void ClientRemoveActorItem_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID, bool showHUDMessage) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, bool>(this, "AShooterPlayerController.ClientRemoveActorItem_Implementation", forInventory, itemID, showHUDMessage); }

    void ClientRemovedItemFromSlot_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ClientRemovedItemFromSlot_Implementation", forInventory, itemID); }

    void ClientReplicateTravelledObjects_Implementation(TArray<UObject*>* Objects) { NativeCall<void, TArray<UObject*>*>(this, "AShooterPlayerController.ClientReplicateTravelledObjects_Implementation", Objects); }

    void ClientResetRespawningFlag_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientResetRespawningFlag_Implementation"); }

    void ClientReset_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientReset_Implementation"); }

    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 ClientSendArkDataPayload_Implementation(FGuid ID, EPrimalARKTributeDataType::Type ArkDataType, TArray<unsigned char>* DataBytes) { NativeCall<void, FGuid, EPrimalARKTributeDataType::Type, TArray<unsigned char>*>(this, "AShooterPlayerController.ClientSendArkDataPayload_Implementation", ID, ArkDataType, DataBytes); }

    void ClientServerChatDirectMessage_Implementation(FString* MessageText, FLinearColor MessageColor, bool bIsBold) { NativeCall<void, FString*, FLinearColor, bool>(this, "AShooterPlayerController.ClientServerChatDirectMessage_Implementation", MessageText, MessageColor, bIsBold); }

    void ClientServerChatMessage_Implementation(FString* MessageText, FLinearColor MessageColor, bool bIsBold) { NativeCall<void, FString*, FLinearColor, bool>(this, "AShooterPlayerController.ClientServerChatMessage_Implementation", MessageText, MessageColor, bIsBold); }

    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 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 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 ClientSetCheatStatus_Implementation(bool bEnable) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientSetCheatStatus_Implementation", bEnable); }

    void ClientSetControlRotation_Implementation(FRotator NewRotation) { NativeCall<void, FRotator>(this, "AShooterPlayerController.ClientSetControlRotation_Implementation", NewRotation); }

    void ClientSetHUDAndInitUIScenes_Implementation(TSubclassOf<AHUD> NewHUDClass) { NativeCall<void, TSubclassOf<AHUD>>(this, "AShooterPlayerController.ClientSetHUDAndInitUIScenes_Implementation", NewHUDClass); }

    void ClientSetSpectatorLocation_Implementation(FVector NewLocation) { NativeCall<void, FVector>(this, "AShooterPlayerController.ClientSetSpectatorLocation_Implementation", NewLocation); }

    void ClientShowCharacterCreationUI_Implementation(bool bShowDownloadCharacter) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientShowCharacterCreationUI_Implementation", bShowDownloadCharacter); }

    void ClientShowPaintingUI_Implementation(UObject* ObjectToPaint) { NativeCall<void, UObject*>(this, "AShooterPlayerController.ClientShowPaintingUI_Implementation", ObjectToPaint); }

    void ClientShowSpawnUI_Implementation(float Delay) { NativeCall<void, float>(this, "AShooterPlayerController.ClientShowSpawnUI_Implementation", Delay); }

    void ClientStartReceivingActorItems_Implementation(UPrimalInventoryComponent* forInventory, bool bEquippedItems) { NativeCall<void, UPrimalInventoryComponent*, bool>(this, "AShooterPlayerController.ClientStartReceivingActorItems_Implementation", forInventory, bEquippedItems); }

    void ClientStartReceivingTribeLog_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientStartReceivingTribeLog_Implementation"); }

    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 ClientStartTravelling_Implementation(unsigned int ServerID, unsigned __int64 ServerSteamId, unsigned __int64 TravelLog, bool UsingBattlEye) { NativeCall<void, unsigned int, unsigned __int64, unsigned __int64, bool>(this, "AShooterPlayerController.ClientStartTravelling_Implementation", ServerID, ServerSteamId, TravelLog, UsingBattlEye); }

    void ClientStartingFastTravel_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientStartingFastTravel_Implementation"); }

    void ClientStopLocalSound_Implementation(USoundBase* aSound) { NativeCall<void, USoundBase*>(this, "AShooterPlayerController.ClientStopLocalSound_Implementation", aSound); }

    void ClientSwapActorItems_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID1, FItemNetID itemID2) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, FItemNetID>(this, "AShooterPlayerController.ClientSwapActorItems_Implementation", forInventory, itemID1, itemID2); }

    void ClientSyncCurrentSublevels_Finish_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientSyncCurrentSublevels_Finish_Implementation"); }

    void ClientSyncCurrentSublevels_RecieveData_Implementation(TArray<FTransformedSubLevel>* CurrentData) { NativeCall<void, TArray<FTransformedSubLevel>*>(this, "AShooterPlayerController.ClientSyncCurrentSublevels_RecieveData_Implementation", CurrentData); }

    void ClientSyncCurrentSublevels_Start_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientSyncCurrentSublevels_Start_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); }

    void ClientTeleportSpectator_Implementation(FVector Location, unsigned __int64 PlayerID) { NativeCall<void, FVector, unsigned __int64>(this, "AShooterPlayerController.ClientTeleportSpectator_Implementation", Location, PlayerID); }

    void ClientTeleportSucceeded_Implementation(FVector TeleportLoc, FRotator TeleportRot, bool bSimpleTeleport) { NativeCall<void, FVector, FRotator, bool>(this, "AShooterPlayerController.ClientTeleportSucceeded_Implementation", TeleportLoc, TeleportRot, bSimpleTeleport); }

    void ClientUnlockAchievement_Implementation(FString* AchievementID) { NativeCall<void, FString*>(this, "AShooterPlayerController.ClientUnlockAchievement_Implementation", AchievementID); }

    void ClientUnlockExplorerNote_Implementation(int ExplorerNoteIndex) { NativeCall<void, int>(this, "AShooterPlayerController.ClientUnlockExplorerNote_Implementation", ExplorerNoteIndex); }

    void ClientUnmarkSeamlessActors_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ClientUnmarkSeamlessActors_Implementation"); }

    void ClientUpdateGroupInfo_Implementation(TArray<FOrderingGroupInfo>* GroupInfos, APrimalRaft* forRaft) { NativeCall<void, TArray<FOrderingGroupInfo>*, APrimalRaft*>(this, "AShooterPlayerController.ClientUpdateGroupInfo_Implementation", GroupInfos, forRaft); }

    void ClientUpdateInventoryCraftQueue_Implementation(UPrimalInventoryComponent* forInventory, TArray<FItemCraftQueueEntry>* CraftQueueEntries) { NativeCall<void, UPrimalInventoryComponent*, TArray<FItemCraftQueueEntry>*>(this, "AShooterPlayerController.ClientUpdateInventoryCraftQueue_Implementation", forInventory, CraftQueueEntries); }

    void ClientUpdateItemDurability_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID, float ItemDurability) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, float>(this, "AShooterPlayerController.ClientUpdateItemDurability_Implementation", forInventory, itemID, ItemDurability); }

    void ClientUpdateItemQuantity_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID, int ItemQuantity) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, int>(this, "AShooterPlayerController.ClientUpdateItemQuantity_Implementation", forInventory, itemID, ItemQuantity); }

    void ClientUpdateItemSpoilingTimes_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID, long double NextSpoilingTime, long double LastSpoilingTime) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, long double, long double>(this, "AShooterPlayerController.ClientUpdateItemSpoilingTimes_Implementation", forInventory, itemID, NextSpoilingTime, LastSpoilingTime); }

    void ClientUpdateItemWeaponClipAmmo_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID, int Ammo) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, int>(this, "AShooterPlayerController.ClientUpdateItemWeaponClipAmmo_Implementation", forInventory, itemID, Ammo); }

    void ClientUpdateUnlockedSkills_Implementation(TArray<TSubclassOf<UPrimalEngramEntry>>* NetUnlockedSkills) { NativeCall<void, TArray<TSubclassOf<UPrimalEngramEntry>>*>(this, "AShooterPlayerController.ClientUpdateUnlockedSkills_Implementation", NetUnlockedSkills); }

    void ClientUsedActorItem_Implementation(UPrimalInventoryComponent* forInventory, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ClientUsedActorItem_Implementation", forInventory, itemID); }

    void Client_CaptainExtraActions_Implementation(ECaptainOtherActions::Type RequestedAction, APrimalStructureSeating_DriverSeat* RequestedFromSeat, int CurrentValue, TSubclassOf<UPrimalItem> SelectedAmmoType) { NativeCall<void, ECaptainOtherActions::Type, APrimalStructureSeating_DriverSeat*, int, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerController.Client_CaptainExtraActions_Implementation", RequestedAction, RequestedFromSeat, CurrentValue, SelectedAmmoType); }

    void CloseFeatsSelection() { NativeCall<void>(this, "AShooterPlayerController.CloseFeatsSelection"); }

    void CollectNearbyTreasures() { NativeCall<void>(this, "AShooterPlayerController.CollectNearbyTreasures"); }

    FString* ConsoleCommand(FString* result, FString* Command, bool bWriteToLog) { return NativeCall<FString*, FString*, FString*, bool>(this, "AShooterPlayerController.ConsoleCommand", result, Command, bWriteToLog); }

    void CopyCoordsToClipboard() { NativeCall<void>(this, "AShooterPlayerController.CopyCoordsToClipboard"); }

    void CreateSpawnUITattooComponent() { NativeCall<void>(this, "AShooterPlayerController.CreateSpawnUITattooComponent"); }

    void DebugStructures() { NativeCall<void>(this, "AShooterPlayerController.DebugStructures"); }

    void DelayedTeamSpectatorSetup() { NativeCall<void>(this, "AShooterPlayerController.DelayedTeamSpectatorSetup"); }

    void Destroyed() { NativeCall<void>(this, "AShooterPlayerController.Destroyed"); }

    void DisableLightingChecker() { NativeCall<void>(this, "AShooterPlayerController.DisableLightingChecker"); }

    void DisableSpectator() { NativeCall<void>(this, "AShooterPlayerController.DisableSpectator"); }

    void DisableSurfaceCameraInterpolation() { NativeCall<void>(this, "AShooterPlayerController.DisableSurfaceCameraInterpolation"); }

    void DisableTimeSlicedPhysX() { NativeCall<void>(this, "AShooterPlayerController.DisableTimeSlicedPhysX"); }

    void DisableViewOnly() { NativeCall<void>(this, "AShooterPlayerController.DisableViewOnly"); }

    void DisallowPlayerToJoinNoCheck(FString* PlayerId) { NativeCall<void, FString*>(this, "AShooterPlayerController.DisallowPlayerToJoinNoCheck", PlayerId); }

    void DoClientInformPickNewHomeServer() { NativeCall<void>(this, "AShooterPlayerController.DoClientInformPickNewHomeServer"); }

    void DoCrash() { NativeCall<void>(this, "AShooterPlayerController.DoCrash"); }

    void DoFastTravel(EFastTravelType FastTravelType, unsigned int ToServerID, FVector GridTravelToPos, unsigned int ToBedID, FVector2D FromRelativeLocInServer) { NativeCall<void, EFastTravelType, unsigned int, FVector, unsigned int, FVector2D>(this, "AShooterPlayerController.DoFastTravel", FastTravelType, ToServerID, GridTravelToPos, ToBedID, FromRelativeLocInServer); }

    void DoFastTravelToShipBed(unsigned int FromBedID, unsigned int ToBedID, bool ToBedIDIsServerID, bool bHomeServerRespawn, bool bValidFromBed, FVector2D FromBedLocation) { NativeCall<void, unsigned int, unsigned int, bool, bool, bool, FVector2D>(this, "AShooterPlayerController.DoFastTravelToShipBed", FromBedID, ToBedID, ToBedIDIsServerID, bHomeServerRespawn, bValidFromBed, FromBedLocation); }

    void DoFlushLevelStreaming() { NativeCall<void>(this, "AShooterPlayerController.DoFlushLevelStreaming"); }

    bool DoMapInput(int Index) { return NativeCall<bool, int>(this, "AShooterPlayerController.DoMapInput", Index); }

    void DoOnCaptainOrderPressed(int OrderIndex) { NativeCall<void, int>(this, "AShooterPlayerController.DoOnCaptainOrderPressed", OrderIndex); }

    void DoOnCaptainOrderReleased(int OrderIndex) { NativeCall<void, int>(this, "AShooterPlayerController.DoOnCaptainOrderReleased", OrderIndex); }

    void DoOnReleaseItemSlot(int Index) { NativeCall<void, int>(this, "AShooterPlayerController.DoOnReleaseItemSlot", Index); }

    void DoOnReleaseUseFeat(int Index) { NativeCall<void, int>(this, "AShooterPlayerController.DoOnReleaseUseFeat", Index); }

    void DoOnUseFeat(int Index) { NativeCall<void, int>(this, "AShooterPlayerController.DoOnUseFeat", Index); }

    void DoOnUseItemSlot(int Index) { NativeCall<void, int>(this, "AShooterPlayerController.DoOnUseItemSlot", Index); }

    void DoServerCheckUnfreeze_Implementation() { NativeCall<void>(this, "AShooterPlayerController.DoServerCheckUnfreeze_Implementation"); }

    void DoTransferToRemoteInventory(UPrimalInventoryComponent* inventoryComp, UPrimalItem* anItem, bool bAlsoTryToEqup, int requestedQuantity) { NativeCall<void, UPrimalInventoryComponent*, UPrimalItem*, bool, int>(this, "AShooterPlayerController.DoTransferToRemoteInventory", inventoryComp, anItem, bAlsoTryToEqup, requestedQuantity); }

    void DrawHUD(AShooterHUD* HUD) { NativeCall<void, AShooterHUD*>(this, "AShooterPlayerController.DrawHUD", HUD); }

    void EnableCheats(FString Pass) { NativeCall<void, FString>(this, "AShooterPlayerController.EnableCheats", Pass); }

    void EnableLightingChecker() { NativeCall<void>(this, "AShooterPlayerController.EnableLightingChecker"); }

    void EnableSpectator() { NativeCall<void>(this, "AShooterPlayerController.EnableSpectator"); }

    void EnableViewOnly() { NativeCall<void>(this, "AShooterPlayerController.EnableViewOnly"); }

    void EndAArkGamepadDpadUp() { NativeCall<void>(this, "AShooterPlayerController.EndAArkGamepadDpadUp"); }

    void EndArkGamepadBackButton() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadBackButton"); }

    void EndArkGamepadDpadDown() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadDpadDown"); }

    void EndArkGamepadDpadLeft() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadDpadLeft"); }

    void EndArkGamepadDpadRight() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadDpadRight"); }

    void EndArkGamepadFaceButtonBottom() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadFaceButtonBottom"); }

    void EndArkGamepadFaceButtonLeft() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadFaceButtonLeft"); }

    void EndArkGamepadFaceButtonRight() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadFaceButtonRight"); }

    void EndArkGamepadFaceButtonTop() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadFaceButtonTop"); }

    void EndArkGamepadLeftShoulder() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadLeftShoulder"); }

    void EndArkGamepadRightShoulder() { NativeCall<void>(this, "AShooterPlayerController.EndArkGamepadRightShoulder"); }

    void EndEmoteSelection() { NativeCall<void>(this, "AShooterPlayerController.EndEmoteSelection"); }

    void EndFeatsSelection() { NativeCall<void>(this, "AShooterPlayerController.EndFeatsSelection"); }

    void EndInventoryRadialSelector() { NativeCall<void>(this, "AShooterPlayerController.EndInventoryRadialSelector"); }

    void EndPlayerActionRadialSelector() { NativeCall<void>(this, "AShooterPlayerController.EndPlayerActionRadialSelector"); }

    void EndSurfaceCamera() { NativeCall<void>(this, "AShooterPlayerController.EndSurfaceCamera"); }

    void EndWhistleSelection() { NativeCall<void>(this, "AShooterPlayerController.EndWhistleSelection"); }

    void EnemyInVisible(bool Invisible) { NativeCall<void, bool>(this, "AShooterPlayerController.EnemyInVisible", Invisible); }

    void FadeOutLoadingMusic() { NativeCall<void>(this, "AShooterPlayerController.FadeOutLoadingMusic"); }

    void FailedToSpawnPawn() { NativeCall<void>(this, "AShooterPlayerController.FailedToSpawnPawn"); }

    void FinalFlushLevelStreaming() { NativeCall<void>(this, "AShooterPlayerController.FinalFlushLevelStreaming"); }

    void FinalStructurePlacement(TSubclassOf<APrimalStructure> theStructureClass, FVector TestBuildLocation, FRotator TestBuildRotation, FRotator PlayerViewRotation, APawn* AttachToPawn, APrimalDinoCharacter* DinoCharacter, FName BoneName, FItemNetID FinalPlacementItemID, bool bSnapped, bool bIsCheat, bool bIsFlipped, int SnapPointCycle, bool bIgnoreClassOverride) { NativeCall<void, TSubclassOf<APrimalStructure>, FVector, FRotator, FRotator, APawn*, APrimalDinoCharacter*, FName, FItemNetID, bool, bool, bool, int, bool>(this, "AShooterPlayerController.FinalStructurePlacement", theStructureClass, TestBuildLocation, TestBuildRotation, PlayerViewRotation, AttachToPawn, DinoCharacter, BoneName, FinalPlacementItemID, bSnapped, bIsCheat, bIsFlipped, SnapPointCycle, bIgnoreClassOverride); }

    void FlushLevelStreaming() { NativeCall<void>(this, "AShooterPlayerController.FlushLevelStreaming"); }

    void FlushPressedKeys() { NativeCall<void>(this, "AShooterPlayerController.FlushPressedKeys"); }

    void FlushPrimalStats() { NativeCall<void>(this, "AShooterPlayerController.FlushPrimalStats"); }

    void ForceAddDinoExperience(float Amount) { NativeCall<void, float>(this, "AShooterPlayerController.ForceAddDinoExperience", Amount); }

    void ForceCraftPressed() { NativeCall<void>(this, "AShooterPlayerController.ForceCraftPressed"); }

    void ForceCraftReleased() { NativeCall<void>(this, "AShooterPlayerController.ForceCraftReleased"); }

    void ForceFlushPressedKeys() { NativeCall<void>(this, "AShooterPlayerController.ForceFlushPressedKeys"); }

    void ForceTame(bool bCheatTame) { NativeCall<void, bool>(this, "AShooterPlayerController.ForceTame", bCheatTame); }

    void ForceTribes(FString* PlayerName1, FString* PlayerName2, FString* NewTribeName) { NativeCall<void, FString*, FString*, FString*>(this, "AShooterPlayerController.ForceTribes", PlayerName1, PlayerName2, NewTribeName); }

    void ForceUnstasisAtLocation(FVector AtLocation) { NativeCall<void, FVector>(this, "AShooterPlayerController.ForceUnstasisAtLocation", AtLocation); }

    void ForceUpdateCaptures() { NativeCall<void>(this, "AShooterPlayerController.ForceUpdateCaptures"); }

    FString* FormatTextWithKeyBindings(FString* result, FString InText, bool bIgnoreMarkup) { return NativeCall<FString*, FString*, FString, bool>(this, "AShooterPlayerController.FormatTextWithKeyBindings", result, InText, bIgnoreMarkup); }

    AActor* GetAimedUseActor(UActorComponent** UseComponent, int* hitBodyIndex, bool bForceUseActorLocation) { return NativeCall<AActor*, UActorComponent**, int*, bool>(this, "AShooterPlayerController.GetAimedUseActor", UseComponent, hitBodyIndex, bForceUseActorLocation); }

    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); }

    void GetAudioListenerPosition(FVector* OutLocation, FVector* OutFrontDir, FVector* OutRightDir) { NativeCall<void, FVector*, FVector*, FVector*>(this, "AShooterPlayerController.GetAudioListenerPosition", OutLocation, OutFrontDir, OutRightDir); }

    TArray<FString>* GetCheatsCommands(TArray<FString>* result) { return NativeCall<TArray<FString>*, TArray<FString>*>(this, "AShooterPlayerController.GetCheatsCommands", result); }

    int GetCurrentMultiUseWheelCategory() { return NativeCall<int>(this, "AShooterPlayerController.GetCurrentMultiUseWheelCategory"); }

    UPrimalItem* GetInventoryUISelectedItemLocal() { return NativeCall<UPrimalItem*>(this, "AShooterPlayerController.GetInventoryUISelectedItemLocal"); }

    UPrimalItem* GetInventoryUISelectedItemRemote() { return NativeCall<UPrimalItem*>(this, "AShooterPlayerController.GetInventoryUISelectedItemRemote"); }

    AActor* GetLastControlledPlayerChar() { return NativeCall<AActor*>(this, "AShooterPlayerController.GetLastControlledPlayerChar"); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "AShooterPlayerController.GetLifetimeReplicatedProps", OutLifetimeProps); }

    unsigned __int64 GetLinkedPlayerID64() { return NativeCall<unsigned __int64>(this, "AShooterPlayerController.GetLinkedPlayerID64"); }

    int GetLinkedPlayerID() { return NativeCall<int>(this, "AShooterPlayerController.GetLinkedPlayerID"); }

    void GetNearbyTreasures(float DesiredDistance, TArray<UPrimalItem*>* OutMapItems) { NativeCall<void, float, TArray<UPrimalItem*>*>(this, "AShooterPlayerController.GetNearbyTreasures", DesiredDistance, OutMapItems); }

    UPrimalInventoryComponent* GetPawnInventoryComponent() { return NativeCall<UPrimalInventoryComponent*>(this, "AShooterPlayerController.GetPawnInventoryComponent"); }

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

    AShooterCharacter* GetPlayerCharacter() { return NativeCall<AShooterCharacter*>(this, "AShooterPlayerController.GetPlayerCharacter"); }

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

    AActor* GetPlayerControllerViewerOverride() { return NativeCall<AActor*>(this, "AShooterPlayerController.GetPlayerControllerViewerOverride"); }

    UPrimalInventoryComponent* GetPlayerInventory() { return NativeCall<UPrimalInventoryComponent*>(this, "AShooterPlayerController.GetPlayerInventory"); }

    UPrimalInventoryComponent* GetPlayerInventoryComponent() { return NativeCall<UPrimalInventoryComponent*>(this, "AShooterPlayerController.GetPlayerInventoryComponent"); }

    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); }

    TArray<unsigned int>* GetRadioFrequencies(TArray<unsigned int>* result) { return NativeCall<TArray<unsigned int>*, TArray<unsigned int>*>(this, "AShooterPlayerController.GetRadioFrequencies", result); }

    APawn* GetResponsibleDamager(AActor* DamageCauser) { return NativeCall<APawn*, AActor*>(this, "AShooterPlayerController.GetResponsibleDamager", DamageCauser); }

    static FString* GetSavedPlayerCharactersPath(FString* result) { return NativeCall<FString*, FString*>(nullptr, "AShooterPlayerController.GetSavedPlayerCharactersPath", result); }

    int GetSubscribedAppIds() { return NativeCall<int>(this, "AShooterPlayerController.GetSubscribedAppIds"); }

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

    FVector* GetViewLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AShooterPlayerController.GetViewLocation", result); }

    void GiveActorToMe(AActor* anAct, bool bNotifyNetwork) { NativeCall<void, AActor*, bool>(this, "AShooterPlayerController.GiveActorToMe", anAct, bNotifyNetwork); }

    void GiveColors(int quantity) { NativeCall<void, int>(this, "AShooterPlayerController.GiveColors", quantity); }

    void GiveEngrams(bool ForceAllEngrams) { NativeCall<void, bool>(this, "AShooterPlayerController.GiveEngrams", ForceAllEngrams); }

    bool GiveFast(FName* blueprintPath, int quantityOverride, float qualityOverride, bool bForceBlueprint) { return NativeCall<bool, FName*, int, float, bool>(this, "AShooterPlayerController.GiveFast", blueprintPath, quantityOverride, qualityOverride, bForceBlueprint); }

    bool GiveItem(FString* blueprintPath, int quantityOverride, float qualityOverride, bool bForceBlueprint) { return NativeCall<bool, FString*, int, float, bool>(this, "AShooterPlayerController.GiveItem", blueprintPath, quantityOverride, qualityOverride, bForceBlueprint); }

    bool GiveItemNum(int masterIndexNum, int quantityOverride, float qualityOverride, bool bForceBlueprint) { return NativeCall<bool, int, int, float, bool>(this, "AShooterPlayerController.GiveItemNum", masterIndexNum, quantityOverride, qualityOverride, bForceBlueprint); }

    void GiveResources() { NativeCall<void>(this, "AShooterPlayerController.GiveResources"); }

    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); }

    void GiveToMe() { NativeCall<void>(this, "AShooterPlayerController.GiveToMe"); }

    void GlobalCommand(FString* Msg) { NativeCall<void, FString*>(this, "AShooterPlayerController.GlobalCommand", Msg); }

    void GridTravelToGlobalPos(FVector* ToGlobalPos) { NativeCall<void, FVector*>(this, "AShooterPlayerController.GridTravelToGlobalPos", ToGlobalPos); }

    void GridTravelToLocalPos(unsigned __int16 GridX, unsigned __int16 GridY, FVector* ToLocalPos) { NativeCall<void, unsigned __int16, unsigned __int16, FVector*>(this, "AShooterPlayerController.GridTravelToLocalPos", GridX, GridY, ToLocalPos); }

    bool HasEngram(TSubclassOf<UPrimalItem> TheItemClass) { return NativeCall<bool, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerController.HasEngram", TheItemClass); }

    bool HasGodMode() { return NativeCall<bool>(this, "AShooterPlayerController.HasGodMode"); }

    bool HasRadio(bool allowVoice) { return NativeCall<bool, bool>(this, "AShooterPlayerController.HasRadio", allowVoice); }

    bool HasSameRadioFrequency(AShooterPlayerController* OtherPC, unsigned int* SharedFrequency) { return NativeCall<bool, AShooterPlayerController*, unsigned int*>(this, "AShooterPlayerController.HasSameRadioFrequency", OtherPC, SharedFrequency); }

    bool HasSkill(TSubclassOf<UPrimalEngramEntry> SkillClass) { return NativeCall<bool, TSubclassOf<UPrimalEngramEntry>>(this, "AShooterPlayerController.HasSkill", SkillClass); }

    void HiWarp(FString* ClassName, int Index) { NativeCall<void, FString*, int>(this, "AShooterPlayerController.HiWarp", ClassName, Index); }

    void HibernationReport(FString* ClassName) { NativeCall<void, FString*>(this, "AShooterPlayerController.HibernationReport", ClassName); }

    void HideRiders(bool bDoHide) { NativeCall<void, bool>(this, "AShooterPlayerController.HideRiders", bDoHide); }

    void HideTutorial(int TutorialIndex) { NativeCall<void, int>(this, "AShooterPlayerController.HideTutorial", TutorialIndex); }

    void IncrementPrimalStats(EPrimalStatsValueTypes::Type statsValueType) { NativeCall<void, EPrimalStatsValueTypes::Type>(this, "AShooterPlayerController.IncrementPrimalStats", statsValueType); }

    void InfiniteStats() { NativeCall<void>(this, "AShooterPlayerController.InfiniteStats"); }

    void InitCharacterPainting_Implementation(APrimalCharacter* Char, bool bForTattoo) { NativeCall<void, APrimalCharacter*, bool>(this, "AShooterPlayerController.InitCharacterPainting_Implementation", Char, bForTattoo); }

    void InitHUD(bool bForceReinitUI) { NativeCall<void, bool>(this, "AShooterPlayerController.InitHUD", bForceReinitUI); }

    void InitInputSystem() { NativeCall<void>(this, "AShooterPlayerController.InitInputSystem"); }

    bool IsAlliedWithTeam(int OtherTargetingTeam, bool bIgnoreSameTeam) { return NativeCall<bool, int, bool>(this, "AShooterPlayerController.IsAlliedWithTeam", OtherTargetingTeam, bIgnoreSameTeam); }

    bool IsAtPersonalTameLimit(bool bIsForStructure) { return NativeCall<bool, bool>(this, "AShooterPlayerController.IsAtPersonalTameLimit", bIsForStructure); }

    bool IsEmoteUnlocked(FName EmoteName) { return NativeCall<bool, FName>(this, "AShooterPlayerController.IsEmoteUnlocked", EmoteName); }

    bool IsFirstLocalPlayer() { return NativeCall<bool>(this, "AShooterPlayerController.IsFirstLocalPlayer"); }

    bool IsFirstLocalPlayerOrLivingLocalPlayer() { return NativeCall<bool>(this, "AShooterPlayerController.IsFirstLocalPlayerOrLivingLocalPlayer"); }

    bool IsGameInputAllowed() { return NativeCall<bool>(this, "AShooterPlayerController.IsGameInputAllowed"); }

    bool IsHeldDownIndexOverriddenFromCaptainsOrders(int index) { return NativeCall<bool, int>(this, "AShooterPlayerController.IsHeldDownIndexOverriddenFromCaptainsOrders", index); }

    bool IsHudVisible() { return NativeCall<bool>(this, "AShooterPlayerController.IsHudVisible"); }

    bool IsInTribe() { return NativeCall<bool>(this, "AShooterPlayerController.IsInTribe"); }

    bool IsOnSeatingStructure() { return NativeCall<bool>(this, "AShooterPlayerController.IsOnSeatingStructure"); }

    bool IsOnlyViewingInventory() { return NativeCall<bool>(this, "AShooterPlayerController.IsOnlyViewingInventory"); }

    bool IsRidingDino() { return NativeCall<bool>(this, "AShooterPlayerController.IsRidingDino"); }

    bool IsSavingData() { return NativeCall<bool>(this, "AShooterPlayerController.IsSavingData"); }

    bool IsSpectator() { return NativeCall<bool>(this, "AShooterPlayerController.IsSpectator"); }

    bool IsTribeAdmin() { return NativeCall<bool>(this, "AShooterPlayerController.IsTribeAdmin"); }

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

    bool IsViewingInventoryUI() { return NativeCall<bool>(this, "AShooterPlayerController.IsViewingInventoryUI"); }

    void KickPlayer(FString PlayerSteamName) { NativeCall<void, FString>(this, "AShooterPlayerController.KickPlayer", PlayerSteamName); }

    void LeaveMeAlone() { NativeCall<void>(this, "AShooterPlayerController.LeaveMeAlone"); }

    void LevelView() { NativeCall<void>(this, "AShooterPlayerController.LevelView"); }

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

    void LoadLocalPlayerArkData() { NativeCall<void>(this, "AShooterPlayerController.LoadLocalPlayerArkData"); }

    void LoadSpectatorPos(int Index) { NativeCall<void, int>(this, "AShooterPlayerController.LoadSpectatorPos", Index); }

    void LockEmote(FName EmoteName) { NativeCall<void, FName>(this, "AShooterPlayerController.LockEmote", EmoteName); }

    void LookInput(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.LookInput", Val); }

    void LookUpAtRate(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.LookUpAtRate", Val); }

    void MoveForward(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.MoveForward", Val); }

    void MoveRight(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.MoveRight", Val); }

    void MulticastCharacterVivoxUsername() { NativeCall<void>(this, "AShooterPlayerController.MulticastCharacterVivoxUsername"); }

    void NotifyTribeWarStatus_Implementation(FString* EnemyTribeString, int StatusType) { NativeCall<void, FString*, int>(this, "AShooterPlayerController.NotifyTribeWarStatus_Implementation", EnemyTribeString, StatusType); }

    void OnAddSteering(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.OnAddSteering", Val); }

    void OnAddThrottle(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.OnAddThrottle", Val); }

    void OnAltAttackPressed() { NativeCall<void>(this, "AShooterPlayerController.OnAltAttackPressed"); }

    void OnAltAttackReleased() { NativeCall<void>(this, "AShooterPlayerController.OnAltAttackReleased"); }

    void OnDisableSpectator_Implementation() { NativeCall<void>(this, "AShooterPlayerController.OnDisableSpectator_Implementation"); }

    void OnEmoteKey1Press() { NativeCall<void>(this, "AShooterPlayerController.OnEmoteKey1Press"); }

    void OnEmoteKey1Release() { NativeCall<void>(this, "AShooterPlayerController.OnEmoteKey1Release"); }

    void OnEmoteKey2Press() { NativeCall<void>(this, "AShooterPlayerController.OnEmoteKey2Press"); }

    void OnEmoteKey2Release() { NativeCall<void>(this, "AShooterPlayerController.OnEmoteKey2Release"); }

    void OnExtendedInfoPress() { NativeCall<void>(this, "AShooterPlayerController.OnExtendedInfoPress"); }

    void OnExtendedInfoRelease() { NativeCall<void>(this, "AShooterPlayerController.OnExtendedInfoRelease"); }

    void OnFastTravelFailed() { NativeCall<void>(this, "AShooterPlayerController.OnFastTravelFailed"); }

    void OnFastTravelFailed_DisableMessage() { NativeCall<void>(this, "AShooterPlayerController.OnFastTravelFailed_DisableMessage"); }

    void OnGamepadUsePress() { NativeCall<void>(this, "AShooterPlayerController.OnGamepadUsePress"); }

    void OnGamepadUseRelease() { NativeCall<void>(this, "AShooterPlayerController.OnGamepadUseRelease"); }

    void OnGetHomeServer(bool bSuccess, FString UserId, unsigned int CurrentSeverId) { NativeCall<void, bool, FString, unsigned int>(this, "AShooterPlayerController.OnGetHomeServer", bSuccess, UserId, CurrentSeverId); }

    void OnHideMapTextPressed() { NativeCall<void>(this, "AShooterPlayerController.OnHideMapTextPressed"); }

    void OnKeyboardUsePress() { NativeCall<void>(this, "AShooterPlayerController.OnKeyboardUsePress"); }

    void OnKeyboardUseRelease() { NativeCall<void>(this, "AShooterPlayerController.OnKeyboardUseRelease"); }

    void OnLevelView() { NativeCall<void>(this, "AShooterPlayerController.OnLevelView"); }

    void OnPressForceSingleWield() { NativeCall<void>(this, "AShooterPlayerController.OnPressForceSingleWield"); }

    void OnPressGroupAddOrRemoveTame() { NativeCall<void>(this, "AShooterPlayerController.OnPressGroupAddOrRemoveTame"); }

    void OnPressSkipTutorialButton() { NativeCall<void>(this, "AShooterPlayerController.OnPressSkipTutorialButton"); }

    void OnReleaseForceSingleWield() { NativeCall<void>(this, "AShooterPlayerController.OnReleaseForceSingleWield"); }

    void OnReleaseSkipTutorialButton() { NativeCall<void>(this, "AShooterPlayerController.OnReleaseSkipTutorialButton"); }

    void OnRep_HomeServerId() { NativeCall<void>(this, "AShooterPlayerController.OnRep_HomeServerId"); }

    void OnRep_Pawn() { NativeCall<void>(this, "AShooterPlayerController.OnRep_Pawn"); }

    void OnRepeatUseHeldTimer() { NativeCall<void>(this, "AShooterPlayerController.OnRepeatUseHeldTimer"); }

    void OnShowAllGroupIcons(char IconsToActivate) { NativeCall<void, char>(this, "AShooterPlayerController.OnShowAllGroupIcons", IconsToActivate); }

    void OnStartFire() { NativeCall<void>(this, "AShooterPlayerController.OnStartFire"); }

    void OnStartFireQuaternary() { NativeCall<void>(this, "AShooterPlayerController.OnStartFireQuaternary"); }

    void OnStartFireSecondary() { NativeCall<void>(this, "AShooterPlayerController.OnStartFireSecondary"); }

    void OnStartFireTertiary() { NativeCall<void>(this, "AShooterPlayerController.OnStartFireTertiary"); }

    void OnStartGamepadLeftFire() { NativeCall<void>(this, "AShooterPlayerController.OnStartGamepadLeftFire"); }

    void OnStartGamepadRightFire() { NativeCall<void>(this, "AShooterPlayerController.OnStartGamepadRightFire"); }

    void OnStartTargeting() { NativeCall<void>(this, "AShooterPlayerController.OnStartTargeting"); }

    void OnStopFire() { NativeCall<void>(this, "AShooterPlayerController.OnStopFire"); }

    void OnStopFireQuaternary() { NativeCall<void>(this, "AShooterPlayerController.OnStopFireQuaternary"); }

    void OnStopFireSecondary() { NativeCall<void>(this, "AShooterPlayerController.OnStopFireSecondary"); }

    void OnStopFireTertiary() { NativeCall<void>(this, "AShooterPlayerController.OnStopFireTertiary"); }

    void OnStopGamepadLeftFire() { NativeCall<void>(this, "AShooterPlayerController.OnStopGamepadLeftFire"); }

    void OnStopGamepadRightFire() { NativeCall<void>(this, "AShooterPlayerController.OnStopGamepadRightFire"); }

    void OnStopShowAllGroupIcons() { NativeCall<void>(this, "AShooterPlayerController.OnStopShowAllGroupIcons"); }

    void OnStopTargeting() { NativeCall<void>(this, "AShooterPlayerController.OnStopTargeting"); }

    void OnToggleDoFMenu() { NativeCall<void>(this, "AShooterPlayerController.OnToggleDoFMenu"); }

    void OnToggleInGameMenu() { NativeCall<void>(this, "AShooterPlayerController.OnToggleInGameMenu"); }

    void OnUseHeldTimer() { NativeCall<void>(this, "AShooterPlayerController.OnUseHeldTimer"); }

    void OnUseItemSlotForStructure(int ItemSlotNumber) { NativeCall<void, int>(this, "AShooterPlayerController.OnUseItemSlotForStructure", ItemSlotNumber); }

    void OnUsePress(bool bFromGamepad) { NativeCall<void, bool>(this, "AShooterPlayerController.OnUsePress", bFromGamepad); }

    void OnUseRelease(bool bFromGamepad) { NativeCall<void, bool>(this, "AShooterPlayerController.OnUseRelease", bFromGamepad); }

    void OnWhistlePress() { NativeCall<void>(this, "AShooterPlayerController.OnWhistlePress"); }

    void OnYarkStartGamepadRightFire(APrimalCharacter* PlayerCharacter) { NativeCall<void, APrimalCharacter*>(this, "AShooterPlayerController.OnYarkStartGamepadRightFire", PlayerCharacter); }

    void PawnLeavingGame() { NativeCall<void>(this, "AShooterPlayerController.PawnLeavingGame"); }

    void PawnPendingDestroy(APawn* inPawn) { NativeCall<void, APawn*>(this, "AShooterPlayerController.PawnPendingDestroy", inPawn); }

    void PlaceStructure(int Index) { NativeCall<void, int>(this, "AShooterPlayerController.PlaceStructure", Index); }

    void PlayHitMarkerCharacterAlly_Implementation(float InHitMarkerScale, bool InWasMeleeHit) { NativeCall<void, float, bool>(this, "AShooterPlayerController.PlayHitMarkerCharacterAlly_Implementation", InHitMarkerScale, InWasMeleeHit); }

    void PlayHitMarkerCharacter_Implementation(float InHitMarkerScale, bool InWasMeleeHit, APrimalCharacter* VictimCharacter) { NativeCall<void, float, bool, APrimalCharacter*>(this, "AShooterPlayerController.PlayHitMarkerCharacter_Implementation", InHitMarkerScale, InWasMeleeHit, VictimCharacter); }

    void PlayHitMarkerStructureAlly_Implementation(float InHitMarkerScale, bool InWasMeleeHit) { NativeCall<void, float, bool>(this, "AShooterPlayerController.PlayHitMarkerStructureAlly_Implementation", InHitMarkerScale, InWasMeleeHit); }

    void PlayHitMarkerStructure_Implementation(float InHitMarkerScale, bool InWasMeleeHit) { NativeCall<void, float, bool>(this, "AShooterPlayerController.PlayHitMarkerStructure_Implementation", InHitMarkerScale, InWasMeleeHit); }

    FString* PlayerCommand_Implementation(FString* result, FString* TheCommand) { return NativeCall<FString*, FString*, FString*>(this, "AShooterPlayerController.PlayerCommand_Implementation", result, TheCommand); }

    void Possess(APawn* inPawn) { NativeCall<void, APawn*>(this, "AShooterPlayerController.Possess", inPawn); }

    void PostInitializeComponents() { NativeCall<void>(this, "AShooterPlayerController.PostInitializeComponents"); }

    void PostProcessInput(const float DeltaTime, const bool bGamePaused) { NativeCall<void, const float, const bool>(this, "AShooterPlayerController.PostProcessInput", DeltaTime, bGamePaused); }

    void PrintColors() { NativeCall<void>(this, "AShooterPlayerController.PrintColors"); }

    void ProcessServerMessages() { NativeCall<void>(this, "AShooterPlayerController.ProcessServerMessages"); }

    void QueueRequestEquippedItems(UPrimalInventoryComponent* invComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.QueueRequestEquippedItems", invComp); }

    void QuitToMainMenu() { NativeCall<void>(this, "AShooterPlayerController.QuitToMainMenu"); }

    void RPCStayAlive_Implementation() { NativeCall<void>(this, "AShooterPlayerController.RPCStayAlive_Implementation"); }

    void ReceivedPlayerState() { NativeCall<void>(this, "AShooterPlayerController.ReceivedPlayerState"); }

    void RefreshMapMarkers() { NativeCall<void>(this, "AShooterPlayerController.RefreshMapMarkers"); }

    void RefreshNeedingMapEntities() { NativeCall<void>(this, "AShooterPlayerController.RefreshNeedingMapEntities"); }

    void ReportLeastSpawnManagers() { NativeCall<void>(this, "AShooterPlayerController.ReportLeastSpawnManagers"); }

    void ReportSpawnManagers() { NativeCall<void>(this, "AShooterPlayerController.ReportSpawnManagers"); }

    void RequestCreateNewPlayerWithArkData(TArray<unsigned char> PlayerArkDataBytes) { NativeCall<void, TArray<unsigned char>>(this, "AShooterPlayerController.RequestCreateNewPlayerWithArkData", PlayerArkDataBytes); }

    void RequestFastTravelToPoint(unsigned int fromSpawnPointID, unsigned int spawnPointID, FVector2D FromBedLocation, bool bFromBedValid) { NativeCall<void, unsigned int, unsigned int, FVector2D, bool>(this, "AShooterPlayerController.RequestFastTravelToPoint", fromSpawnPointID, spawnPointID, FromBedLocation, bFromBedValid); }

    void RequestSpectator(FString InSpectatorPass) { NativeCall<void, FString>(this, "AShooterPlayerController.RequestSpectator", InSpectatorPass); }

    void Reset() { NativeCall<void>(this, "AShooterPlayerController.Reset"); }

    void ResetSpawnTime() { NativeCall<void>(this, "AShooterPlayerController.ResetSpawnTime"); }

    void SCP() { NativeCall<void>(this, "AShooterPlayerController.SCP"); }

    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); }

    bool SameLinkedId(__int64 value) { return NativeCall<bool, __int64>(this, "AShooterPlayerController.SameLinkedId", value); }

    void SaveCharacter() { NativeCall<void>(this, "AShooterPlayerController.SaveCharacter"); }

    void SaveProfile() { NativeCall<void>(this, "AShooterPlayerController.SaveProfile"); }

    void SaveSpectatorPos(int Index) { NativeCall<void, int>(this, "AShooterPlayerController.SaveSpectatorPos", Index); }

    void ScrollChatDown() { NativeCall<void>(this, "AShooterPlayerController.ScrollChatDown"); }

    void ScrollChatUp() { NativeCall<void>(this, "AShooterPlayerController.ScrollChatUp"); }

    void SendAlarmNotification(FString SteamID, FString Title, FString Message) { NativeCall<void, FString, FString, FString>(this, "AShooterPlayerController.SendAlarmNotification", SteamID, Title, Message); }

    bool SendUseItemSlotToStructure() { return NativeCall<bool>(this, "AShooterPlayerController.SendUseItemSlotToStructure"); }

    void ServerActorCloseRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerActorCloseRemoteInventory_Implementation", inventoryComp); }

    void ServerActorViewRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerActorViewRemoteInventory_Implementation", inventoryComp); }

    void ServerAddAchievementID_Implementation(FString* AchievementID, bool bIsOnSpawn) { NativeCall<void, FString*, bool>(this, "AShooterPlayerController.ServerAddAchievementID_Implementation", AchievementID, bIsOnSpawn); }

    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 ServerAddTribeMarker_Implementation(FString* Name, float Coord1, float Coord2, FColor TextColor) { NativeCall<void, FString*, float, float, FColor>(this, "AShooterPlayerController.ServerAddTribeMarker_Implementation", Name, Coord1, Coord2, TextColor); }

    void ServerAllowPlayerToJoinNoCheck_Implementation(FString* PlayerId) { NativeCall<void, FString*>(this, "AShooterPlayerController.ServerAllowPlayerToJoinNoCheck_Implementation", PlayerId); }

    void ServerBanPlayer_Implementation(FString* PlayerSteamName, FString* PlayerSteamID) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ServerBanPlayer_Implementation", PlayerSteamName, PlayerSteamID); }

    void ServerChangeHomeServer_Implementation(unsigned int NewHomeServerId) { NativeCall<void, unsigned int>(this, "AShooterPlayerController.ServerChangeHomeServer_Implementation", NewHomeServerId); }

    void ServerCheckUnfreeze_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerCheckUnfreeze_Implementation"); }

    void ServerCraftItem_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerCraftItem_Implementation", inventoryComp, itemID); }

    void ServerCycleSpectator_Implementation(bool bNext) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerCycleSpectator_Implementation", bNext); }

    void ServerDPC_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerDPC_Implementation"); }

    void ServerDeleteCustomFolder_Implementation(UPrimalInventoryComponent* forInventory, FString* CFolderName, int InventoryCompType) { NativeCall<void, UPrimalInventoryComponent*, FString*, int>(this, "AShooterPlayerController.ServerDeleteCustomFolder_Implementation", forInventory, CFolderName, InventoryCompType); }

    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 ServerDisallowPlayerToJoinNoCheck_Implementation(FString* PlayerId) { NativeCall<void, FString*>(this, "AShooterPlayerController.ServerDisallowPlayerToJoinNoCheck_Implementation", PlayerId); }

    void ServerDropFromRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, bool bOnlyIfEquipped) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, bool>(this, "AShooterPlayerController.ServerDropFromRemoteInventory_Implementation", inventoryComp, itemID, bOnlyIfEquipped); }

    void ServerEquipPawnItem_Implementation(FItemNetID itemID) { NativeCall<void, FItemNetID>(this, "AShooterPlayerController.ServerEquipPawnItem_Implementation", itemID); }

    void ServerEquipToRemoteInventory_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerEquipToRemoteInventory_Implementation", inventoryComp, itemID); }

    void ServerGetHomeServerId() { NativeCall<void>(this, "AShooterPlayerController.ServerGetHomeServerId"); }

    void ServerGetMessageOfTheDay_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerGetMessageOfTheDay_Implementation"); }

    void ServerGetNotificationSettings_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerGetNotificationSettings_Implementation"); }

    void ServerGetOriginalHairColor_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerGetOriginalHairColor_Implementation"); }

    void ServerGlobalCommand_Implementation(FString* Msg) { NativeCall<void, FString*>(this, "AShooterPlayerController.ServerGlobalCommand_Implementation", Msg); }

    void ServerInventoryClearCraftQueue_Implementation(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerInventoryClearCraftQueue_Implementation", inventoryComp); }

    void ServerKickPlayer_Implementation(FString* PlayerSteamName, FString* PlayerSteamID) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ServerKickPlayer_Implementation", PlayerSteamName, PlayerSteamID); }

    void ServerListPlayers_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerListPlayers_Implementation"); }

    void ServerLoginToVivox_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerLoginToVivox_Implementation"); }

    void ServerMultiUse_Implementation(UObject* ForObject, int useIndex) { NativeCall<void, UObject*, int>(this, "AShooterPlayerController.ServerMultiUse_Implementation", ForObject, useIndex); }

    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 ServerReadMessageOFTheDay_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerReadMessageOFTheDay_Implementation"); }

    void ServerReleaseSeatingStructure_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerReleaseSeatingStructure_Implementation"); }

    void ServerRemovePassenger_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerRemovePassenger_Implementation"); }

    void ServerRemovePawnItem_Implementation(FItemNetID itemID, bool bSecondryAction, bool bOnlyIfEquipped) { NativeCall<void, FItemNetID, bool, bool>(this, "AShooterPlayerController.ServerRemovePawnItem_Implementation", itemID, bSecondryAction, bOnlyIfEquipped); }

    void ServerRemoveTribeMarker_Implementation(unsigned int MarkerID) { NativeCall<void, unsigned int>(this, "AShooterPlayerController.ServerRemoveTribeMarker_Implementation", MarkerID); }

    void ServerRepairItem_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRepairItem_Implementation", inventoryComp, itemID); }

    void ServerRepeatMultiUse_Implementation(UObject* ForObject, int useIndex) { NativeCall<void, UObject*, int>(this, "AShooterPlayerController.ServerRepeatMultiUse_Implementation", ForObject, useIndex); }

    void ServerRequestActivateFeat_Implementation(TSubclassOf<APrimalBuff> FeatClass) { NativeCall<void, TSubclassOf<APrimalBuff>>(this, "AShooterPlayerController.ServerRequestActivateFeat_Implementation", FeatClass); }

    void ServerRequestActivateStationGroup_Implementation(APrimalRaft* forRaft, int GroupIndex, bool bActivateForCaptain, bool bNewValue) { NativeCall<void, APrimalRaft*, int, bool, bool>(this, "AShooterPlayerController.ServerRequestActivateStationGroup_Implementation", forRaft, GroupIndex, bActivateForCaptain, bNewValue); }

    void ServerRequestActorItems_Implementation(UPrimalInventoryComponent* forInventory, bool bInventoryItems, bool bIsFirstSpawn, bool allowLocalController) { NativeCall<void, UPrimalInventoryComponent*, bool, bool, bool>(this, "AShooterPlayerController.ServerRequestActorItems_Implementation", forInventory, bInventoryItems, bIsFirstSpawn, allowLocalController); }

    void ServerRequestCreateNewPlayerWithArkData(TArray<unsigned char>* DataBytes, unsigned __int64 TribeID) { NativeCall<void, TArray<unsigned char>*, unsigned __int64>(this, "AShooterPlayerController.ServerRequestCreateNewPlayerWithArkData", DataBytes, TribeID); }

    void ServerRequestDinoAncestors_Implementation(APrimalDinoCharacter* ForDino) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterPlayerController.ServerRequestDinoAncestors_Implementation", ForDino); }

    void ServerRequestDropAllItems_Implementation(FString* CurrentCustomFolderFilter, FString* CurrentNameFilter) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ServerRequestDropAllItems_Implementation", CurrentCustomFolderFilter, CurrentNameFilter); }

    void ServerRequestFastTravelToPoint_Implementation(unsigned int fromSpawnPointID, unsigned int spawnPointID) { NativeCall<void, unsigned int, unsigned int>(this, "AShooterPlayerController.ServerRequestFastTravelToPoint_Implementation", fromSpawnPointID, spawnPointID); }

    void ServerRequestFastTravelToShipBed_Implementation(unsigned int FromBedID, unsigned int ToBedID) { NativeCall<void, unsigned int, unsigned int>(this, "AShooterPlayerController.ServerRequestFastTravelToShipBed_Implementation", FromBedID, ToBedID); }

    void ServerRequestFullMapEntities_Implementation(int ClientFullMapEntitiesChangeID, int ClientFullMapEntitiesCount) { NativeCall<void, int, int>(this, "AShooterPlayerController.ServerRequestFullMapEntities_Implementation", ClientFullMapEntitiesChangeID, ClientFullMapEntitiesCount); }

    void ServerRequestInitiateSettlementWar_Implementation(int requestIslandId, int requestStartTime, FItemNetID RequestUseItem) { NativeCall<void, int, int, FItemNetID>(this, "AShooterPlayerController.ServerRequestInitiateSettlementWar_Implementation", requestIslandId, requestStartTime, RequestUseItem); }

    void ServerRequestInventorySwapItems_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID1, FItemNetID itemID2) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, FItemNetID>(this, "AShooterPlayerController.ServerRequestInventorySwapItems_Implementation", inventoryComp, itemID1, itemID2); }

    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 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 ServerRequestInventoryUseItem_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestInventoryUseItem_Implementation", inventoryComp, itemID); }

    void ServerRequestLevelUp_Implementation(UPrimalCharacterStatusComponent* forStatusComp, EPrimalCharacterStatusValue::Type ValueType) { NativeCall<void, UPrimalCharacterStatusComponent*, EPrimalCharacterStatusValue::Type>(this, "AShooterPlayerController.ServerRequestLevelUp_Implementation", forStatusComp, ValueType); }

    void ServerRequestMyClientTribeData_Implementation(unsigned int TribeMarkerVersion) { NativeCall<void, unsigned int>(this, "AShooterPlayerController.ServerRequestMyClientTribeData_Implementation", TribeMarkerVersion); }

    void ServerRequestMyClientTribeMemberData_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerRequestMyClientTribeMemberData_Implementation"); }

    void ServerRequestMyClientTribeMembersLastOnlineAt_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerRequestMyClientTribeMembersLastOnlineAt_Implementation"); }

    void ServerRequestMyClientTribeRankGroup_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerRequestMyClientTribeRankGroup_Implementation"); }

    void ServerRequestMyTribeOnlineList_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerRequestMyTribeOnlineList_Implementation"); }

    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, TSubclassOf<APrimalStructure> DirectStructurePlacementClass) { NativeCall<void, int, FVector, FRotator, FRotator, APawn*, APrimalDinoCharacter*, FName, FItemNetID, bool, bool, bool, int, TSubclassOf<APrimalStructure>>(this, "AShooterPlayerController.ServerRequestPlaceStructure_Implementation", StructureIndex, BuildLocation, BuildRotation, PlayerViewRotation, AttachToPawn, DinoCharacter, BoneName, PlaceUsingItemID, bSnapped, bIsCheat, bIsFlipped, SnapPointCycle, DirectStructurePlacementClass); }

    void ServerRequestRemoteDropAllItems_Implementation(UPrimalInventoryComponent* inventoryComp, FString* CurrentCustomFolderFilter, FString* CurrentNameFilter) { NativeCall<void, UPrimalInventoryComponent*, FString*, FString*>(this, "AShooterPlayerController.ServerRequestRemoteDropAllItems_Implementation", inventoryComp, CurrentCustomFolderFilter, CurrentNameFilter); }

    void ServerRequestRemoveItemSkinOnly_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestRemoveItemSkinOnly_Implementation", inventoryComp, itemID); }

    void ServerRequestRemoveItemSkin_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ServerRequestRemoveItemSkin_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 ServerRequestRespawnAtPoint_Implementation(unsigned int spawnPointID, int spawnRegionIndex) { NativeCall<void, unsigned int, int>(this, "AShooterPlayerController.ServerRequestRespawnAtPoint_Implementation", spawnPointID, spawnRegionIndex); }

    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 ServerRequestStructureCraftingStatItem_Implementation(APrimalStructure* ForStructure) { NativeCall<void, APrimalStructure*>(this, "AShooterPlayerController.ServerRequestStructureCraftingStatItem_Implementation", ForStructure); }

    void ServerRequestTribeLog_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerRequestTribeLog_Implementation"); }

    void ServerRequestUpdateGroupInfo_Implementation(APrimalRaft* forRaft) { NativeCall<void, APrimalRaft*>(this, "AShooterPlayerController.ServerRequestUpdateGroupInfo_Implementation", forRaft); }

    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 ServerSendArkDataPayloadEnd_Implementation(FGuid ID, EPrimalARKTributeDataType::Type ArkDataType) { NativeCall<void, FGuid, EPrimalARKTributeDataType::Type>(this, "AShooterPlayerController.ServerSendArkDataPayloadEnd_Implementation", ID, ArkDataType); }

    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 ServerSendChatMessage_Implementation(FString* ChatMessage, EChatSendMode::Type SendMode) { NativeCall<void, FString*, EChatSendMode::Type>(this, "AShooterPlayerController.ServerSendChatMessage_Implementation", ChatMessage, SendMode); }

    void ServerSendDirectMessage_Implementation(FString* PlayerSteamID, FString* MessageText) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ServerSendDirectMessage_Implementation", PlayerSteamID, MessageText); }

    void ServerSetAltHeld_Implementation(bool bNewAltHeld) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerSetAltHeld_Implementation", bNewAltHeld); }

    void ServerSetForceSingleWield_Implementation(bool doSet) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerSetForceSingleWield_Implementation", doSet); }

    void ServerSetMessageOfTheDay_Implementation(FString* Message) { NativeCall<void, FString*>(this, "AShooterPlayerController.ServerSetMessageOfTheDay_Implementation", Message); }

    void ServerSetNetIsCurrentlyFirstPerson_Implementation(bool bIsCurrentlyFirstPerson) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerSetNetIsCurrentlyFirstPerson_Implementation", bIsCurrentlyFirstPerson); }

    void ServerSetPlayerForceSwitchAsPrimaryWeaponOnce_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerSetPlayerForceSwitchAsPrimaryWeaponOnce_Implementation"); }

    void ServerSetSpectatorLocation_Implementation(FVector NewLoc) { NativeCall<void, FVector>(this, "AShooterPlayerController.ServerSetSpectatorLocation_Implementation", NewLoc); }

    void ServerSetSubscribedApp_Implementation(int AppID, bool bPreventDefaultItems) { NativeCall<void, int, bool>(this, "AShooterPlayerController.ServerSetSubscribedApp_Implementation", AppID, bPreventDefaultItems); }

    void ServerSetSupressAdminIcon_Implementation(bool bSuppress) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerSetSupressAdminIcon_Implementation", bSuppress); }

    void ServerSetThrottleAndControlRotation_Implementation(float Throttle, float Pitch, float Yaw, FVector AimLocation) { NativeCall<void, float, float, float, FVector>(this, "AShooterPlayerController.ServerSetThrottleAndControlRotation_Implementation", Throttle, Pitch, Yaw, AimLocation); }

    void ServerSetVRPlayer_Implementation(bool bSetVRPlayer) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerSetVRPlayer_Implementation", bSetVRPlayer); }

    void ServerShowMessageOfTheDay_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerShowMessageOfTheDay_Implementation"); }

    void ServerSpectateToPlayerByID_Implementation(unsigned __int64 PlayerID) { NativeCall<void, unsigned __int64>(this, "AShooterPlayerController.ServerSpectateToPlayerByID_Implementation", PlayerID); }

    void ServerStartWeaponAltFire_Implementation(AShooterWeapon* weapon) { NativeCall<void, AShooterWeapon*>(this, "AShooterPlayerController.ServerStartWeaponAltFire_Implementation", weapon); }

    void ServerStartWeaponFire_Implementation(AShooterWeapon* weapon, int attackIndex, bool bIsUsingAltAnim) { NativeCall<void, AShooterWeapon*, int, bool>(this, "AShooterPlayerController.ServerStartWeaponFire_Implementation", weapon, attackIndex, bIsUsingAltAnim); }

    void ServerStopSpectating_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerStopSpectating_Implementation"); }

    void ServerStopWeaponAltFire_Implementation(AShooterWeapon* weapon) { NativeCall<void, AShooterWeapon*>(this, "AShooterPlayerController.ServerStopWeaponAltFire_Implementation", weapon); }

    void ServerStopWeaponFire_Implementation(AShooterWeapon* weapon, int attackIndex, bool bIsUsingAltAnim) { NativeCall<void, AShooterWeapon*, int, bool>(this, "AShooterPlayerController.ServerStopWeaponFire_Implementation", weapon, attackIndex, bIsUsingAltAnim); }

    void ServerSuccessfullyLoggedIntoVivox_Implementation(FString* LoginSessionUserUri) { NativeCall<void, FString*>(this, "AShooterPlayerController.ServerSuccessfullyLoggedIntoVivox_Implementation", LoginSessionUserUri); }

    void ServerSuicide_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerSuicide_Implementation"); }

    void ServerToggleAllShipLadders_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerToggleAllShipLadders_Implementation"); }

    void ServerToggleOpenAllActiveGunports_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerToggleOpenAllActiveGunports_Implementation"); }

    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); }

    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 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 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 ServerTryRespec_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerTryRespec_Implementation"); }

    void ServerTrySettingViewOnlyInventoryStatus_Implementation() { NativeCall<void>(this, "AShooterPlayerController.ServerTrySettingViewOnlyInventoryStatus_Implementation"); }

    void ServerUnbanPlayer_Implementation(FString* PlayerSteamName, FString* PlayerSteamID) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ServerUnbanPlayer_Implementation", PlayerSteamName, PlayerSteamID); }

    void ServerUnlockPerMapExplorerNote_Implementation(int ExplorerNoteIndex) { NativeCall<void, int>(this, "AShooterPlayerController.ServerUnlockPerMapExplorerNote_Implementation", ExplorerNoteIndex); }

    void ServerUpdateManualFireLocation_Implementation(FVector TargetLocation) { NativeCall<void, FVector>(this, "AShooterPlayerController.ServerUpdateManualFireLocation_Implementation", TargetLocation); }

    void ServerUpgradeItem_Implementation(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, int ItemStatModifierIndexToUpgrade, int ItemStatGroupIndexToUpgrade) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, int, int>(this, "AShooterPlayerController.ServerUpgradeItem_Implementation", inventoryComp, itemID, ItemStatModifierIndexToUpgrade, ItemStatGroupIndexToUpgrade); }

    void ServerUploadCharacterDataToArk_Implementation(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerUploadCharacterDataToArk_Implementation", inventoryComp); }

    void Server_CaptainExtraActions_Implementation(ECaptainOtherActions::Type RequestedAction, APrimalStructureSeating_DriverSeat* RequestedFromSeat, int CurrentValue) { NativeCall<void, ECaptainOtherActions::Type, APrimalStructureSeating_DriverSeat*, int>(this, "AShooterPlayerController.Server_CaptainExtraActions_Implementation", RequestedAction, RequestedFromSeat, CurrentValue); }

    void Server_SetShipSailRotation_Implementation(float InSailRotation) { NativeCall<void, float>(this, "AShooterPlayerController.Server_SetShipSailRotation_Implementation", InSailRotation); }

    void Server_SetShipSteeringInput_Implementation(float InSteering) { NativeCall<void, float>(this, "AShooterPlayerController.Server_SetShipSteeringInput_Implementation", InSteering); }

    void Server_SetShipThrottleTarget_Implementation(float InThrottle) { NativeCall<void, float>(this, "AShooterPlayerController.Server_SetShipThrottleTarget_Implementation", InThrottle); }

    void Server_SetWantsForcedMovement_Implementation(int Direction) { NativeCall<void, int>(this, "AShooterPlayerController.Server_SetWantsForcedMovement_Implementation", Direction); }

    void Server_UpdateRowing_Implementation(float InRowingThrottle, float InRowingSteering, int FromSeatNumber) { NativeCall<void, float, float, int>(this, "AShooterPlayerController.Server_UpdateRowing_Implementation", InRowingThrottle, InRowingSteering, FromSeatNumber); }

    void SetAdminIcon(bool bAdminIcon) { NativeCall<void, bool>(this, "AShooterPlayerController.SetAdminIcon", bAdminIcon); }

    void ApplyAutoAimSlider(float NewValue) { NativeCall<void, float>(this, "AShooterPlayerController.ApplyAutoAimSlider", NewValue); }

    void SetCheatPlayer(bool bEnable) { NativeCall<void, bool>(this, "AShooterPlayerController.SetCheatPlayer", 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 SetControlRotation(FRotator* NewRotation) { NativeCall<void, FRotator*>(this, "AShooterPlayerController.SetControlRotation", NewRotation); }

    void SetControllerGamepadActive(bool bIsActive) { NativeCall<void, bool>(this, "AShooterPlayerController.SetControllerGamepadActive", bIsActive); }

    void SetDir(float windDir) { NativeCall<void, float>(this, "AShooterPlayerController.SetDir", windDir); }

    void SetDoFInterpTime(float InterpTime) { NativeCall<void, float>(this, "AShooterPlayerController.SetDoFInterpTime", InterpTime); }

    void SetEquipMap(unsigned int typeIndex) { NativeCall<void, unsigned int>(this, "AShooterPlayerController.SetEquipMap", typeIndex); }

    void SetGamma1() { NativeCall<void>(this, "AShooterPlayerController.SetGamma1"); }

    void SetGamma2() { NativeCall<void>(this, "AShooterPlayerController.SetGamma2"); }

    void SetGodMode(bool bEnable) { NativeCall<void, bool>(this, "AShooterPlayerController.SetGodMode", bEnable); }

    void SetGraphicsQuality(int val) { NativeCall<void, int>(this, "AShooterPlayerController.SetGraphicsQuality", val); }

    void SetImprintQuality(float ImprintingQuality) { NativeCall<void, float>(this, "AShooterPlayerController.SetImprintQuality", ImprintingQuality); }

    void SetKickedNotification(FString KickReason) { NativeCall<void, FString>(this, "AShooterPlayerController.SetKickedNotification", KickReason); }

    void SetMultiUseWheelCategory(int Category) { NativeCall<void, int>(this, "AShooterPlayerController.SetMultiUseWheelCategory", Category); }

    void SetPawn(APawn* InPawn) { NativeCall<void, APawn*>(this, "AShooterPlayerController.SetPawn", InPawn); }

    void SetPlayer(UPlayer* InPlayer) { NativeCall<void, UPlayer*>(this, "AShooterPlayerController.SetPlayer", InPlayer); }

    void SetPlayerPos(float X, float Y, float Z) { NativeCall<void, float, float, float>(this, "AShooterPlayerController.SetPlayerPos", X, Y, Z); }

    void SetSextantMapZoomLevel(float Zoom) { NativeCall<void, float>(this, "AShooterPlayerController.SetSextantMapZoomLevel", Zoom); }

    void SetTutorialHintText(FString* HintText) { NativeCall<void, FString*>(this, "AShooterPlayerController.SetTutorialHintText", HintText); }

    void SetWind(float wind) { NativeCall<void, float>(this, "AShooterPlayerController.SetWind", wind); }

    void SetupInputComponent() { NativeCall<void>(this, "AShooterPlayerController.SetupInputComponent"); }

    bool ShouldHideGameplayUI() { return NativeCall<bool>(this, "AShooterPlayerController.ShouldHideGameplayUI"); }

    bool ShouldReplicateVoicePacketFrom(FUniqueNetId* Sender, char ShouldUseSuperRange, char* PlaybackFlags) { return NativeCall<bool, FUniqueNetId*, char, char*>(this, "AShooterPlayerController.ShouldReplicateVoicePacketFrom", Sender, ShouldUseSuperRange, PlaybackFlags); }

    void ShowAllPlayersListToFollow() { NativeCall<void>(this, "AShooterPlayerController.ShowAllPlayersListToFollow"); }

    void ShowAllianceChat() { NativeCall<void>(this, "AShooterPlayerController.ShowAllianceChat"); }

    void ShowBattleGameModeHUD() { NativeCall<void>(this, "AShooterPlayerController.ShowBattleGameModeHUD"); }

    void ShowGlobalChat() { NativeCall<void>(this, "AShooterPlayerController.ShowGlobalChat"); }

    void ShowInGameMenu() { NativeCall<void>(this, "AShooterPlayerController.ShowInGameMenu"); }

    void ShowLocalChat() { NativeCall<void>(this, "AShooterPlayerController.ShowLocalChat"); }

    void ShowMyAdminManager() { NativeCall<void>(this, "AShooterPlayerController.ShowMyAdminManager"); }

    void ShowMyCraftables() { NativeCall<void>(this, "AShooterPlayerController.ShowMyCraftables"); }

    void ShowMyInventory() { NativeCall<void>(this, "AShooterPlayerController.ShowMyInventory"); }

    void ShowSextantMap(bool bShow) { NativeCall<void, bool>(this, "AShooterPlayerController.ShowSextantMap", bShow); }

    void ShowTribeChat() { NativeCall<void>(this, "AShooterPlayerController.ShowTribeChat"); }

    void ShowTribeManager() { NativeCall<void>(this, "AShooterPlayerController.ShowTribeManager"); }

    void ShowTutorial(int TutorialIndex, bool bForceDisplay) { NativeCall<void, int, bool>(this, "AShooterPlayerController.ShowTutorial", TutorialIndex, bForceDisplay); }

    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); }

    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 SpawnHUD(TSubclassOf<AHUD> NewHUDClass) { NativeCall<void, TSubclassOf<AHUD>>(this, "AShooterPlayerController.SpawnHUD", NewHUDClass); }

    void SpawnPlayerCameraManager() { NativeCall<void>(this, "AShooterPlayerController.SpawnPlayerCameraManager"); }

    void SpectatorDetachOrbitCamera() { NativeCall<void>(this, "AShooterPlayerController.SpectatorDetachOrbitCamera"); }

    void SpectatorNextPlayer() { NativeCall<void>(this, "AShooterPlayerController.SpectatorNextPlayer"); }

    void SpectatorPreviousPlayer() { NativeCall<void>(this, "AShooterPlayerController.SpectatorPreviousPlayer"); }

    void SpectatorTurn(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.SpectatorTurn", Val); }

    void SpectatorUseItem(int Index) { NativeCall<void, int>(this, "AShooterPlayerController.SpectatorUseItem", Index); }

    void StartArkGamepadBackButton() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadBackButton"); }

    void StartArkGamepadDpadDown() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadDpadDown"); }

    void StartArkGamepadDpadLeft() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadDpadLeft"); }

    void StartArkGamepadDpadRight() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadDpadRight"); }

    void StartArkGamepadDpadUp() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadDpadUp"); }

    void StartArkGamepadFaceButtonBottom() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadFaceButtonBottom"); }

    void StartArkGamepadFaceButtonLeft() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadFaceButtonLeft"); }

    void StartArkGamepadFaceButtonRight() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadFaceButtonRight"); }

    void StartArkGamepadFaceButtonTop() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadFaceButtonTop"); }

    void StartArkGamepadLeftShoulder() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadLeftShoulder"); }

    void StartArkGamepadRightShoulder() { NativeCall<void>(this, "AShooterPlayerController.StartArkGamepadRightShoulder"); }

    void StartEmoteSelection() { NativeCall<void>(this, "AShooterPlayerController.StartEmoteSelection"); }

    void StartFeatsSelection() { NativeCall<void>(this, "AShooterPlayerController.StartFeatsSelection"); }

    void StartInventoryRadialSelector() { NativeCall<void>(this, "AShooterPlayerController.StartInventoryRadialSelector"); }

    void StartPlayerActionRadialSelector() { NativeCall<void>(this, "AShooterPlayerController.StartPlayerActionRadialSelector"); }

    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 StartTalkingWrapper() { NativeCall<void>(this, "AShooterPlayerController.StartTalkingWrapper"); }

    void StartWhispering() { NativeCall<void>(this, "AShooterPlayerController.StartWhispering"); }

    void StartWhistleSelection() { NativeCall<void>(this, "AShooterPlayerController.StartWhistleSelection"); }

    void StartYelling() { NativeCall<void>(this, "AShooterPlayerController.StartYelling"); }

    void StopLoadingMusic() { NativeCall<void>(this, "AShooterPlayerController.StopLoadingMusic"); }

    void StopSpectating() { NativeCall<void>(this, "AShooterPlayerController.StopSpectating"); }

    void StopTalkingWrapper() { NativeCall<void>(this, "AShooterPlayerController.StopTalkingWrapper"); }

    void SwitchToNextLoadedWeapon() { NativeCall<void>(this, "AShooterPlayerController.SwitchToNextLoadedWeapon"); }

    void TestAlarmNotification(FString Title, FString Message) { NativeCall<void, FString, FString>(this, "AShooterPlayerController.TestAlarmNotification", Title, Message); }

    void TestNotification() { NativeCall<void>(this, "AShooterPlayerController.TestNotification"); }

    static void TickStasisForCharacter(UWorld* theWorld, AShooterCharacter* Character, FVector ActorLocation) { NativeCall<void, UWorld*, AShooterCharacter*, FVector>(nullptr, "AShooterPlayerController.TickStasisForCharacter", theWorld, Character, ActorLocation); }

    void ToggleAutoChat() { NativeCall<void>(this, "AShooterPlayerController.ToggleAutoChat"); }

    void ToggleDinoNameTags() { NativeCall<void>(this, "AShooterPlayerController.ToggleDinoNameTags"); }

    void ToggleGun() { NativeCall<void>(this, "AShooterPlayerController.ToggleGun"); }

    void ToggleHUDHidden() { NativeCall<void>(this, "AShooterPlayerController.ToggleHUDHidden"); }

    void ToggleHud() { NativeCall<void>(this, "AShooterPlayerController.ToggleHud"); }

    void ToggleMap() { NativeCall<void>(this, "AShooterPlayerController.ToggleMap"); }

    void ToggleMapReleased() { NativeCall<void>(this, "AShooterPlayerController.ToggleMapReleased"); }

    void ToggleShowAllPlayersWhenSpectating() { NativeCall<void>(this, "AShooterPlayerController.ToggleShowAllPlayersWhenSpectating"); }

    void ToggleShowAllPlayersWhenSpectatingLocal() { NativeCall<void>(this, "AShooterPlayerController.ToggleShowAllPlayersWhenSpectatingLocal"); }

    void ToggleSpeaking(bool bSpeaking, bool UseSuperRange) { NativeCall<void, bool, bool>(this, "AShooterPlayerController.ToggleSpeaking", bSpeaking, UseSuperRange); }

    void ToggleWeaponAccessory() { NativeCall<void>(this, "AShooterPlayerController.ToggleWeaponAccessory"); }

    void TriggerPlayerAction(int ActionIndex) { NativeCall<void, int>(this, "AShooterPlayerController.TriggerPlayerAction", ActionIndex); }

    void TryRespec() { NativeCall<void>(this, "AShooterPlayerController.TryRespec"); }

    void TurnAtRate(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.TurnAtRate", Val); }

    void TurnInput(float Val) { NativeCall<void, float>(this, "AShooterPlayerController.TurnInput", Val); }

    void UnFreeze() { NativeCall<void>(this, "AShooterPlayerController.UnFreeze"); }

    void UnPossess() { NativeCall<void>(this, "AShooterPlayerController.UnPossess"); }

    void UnbanPlayer(FString PlayerSteamName) { NativeCall<void, FString>(this, "AShooterPlayerController.UnbanPlayer", PlayerSteamName); }

    void UnlockEmote(FName EmoteName) { NativeCall<void, FName>(this, "AShooterPlayerController.UnlockEmote", EmoteName); }

    void UnlockExplorerNote(int ExplorerNoteIndex) { NativeCall<void, int>(this, "AShooterPlayerController.UnlockExplorerNote", ExplorerNoteIndex); }

    void UnlockFeat(FName FeatName) { NativeCall<void, FName>(this, "AShooterPlayerController.UnlockFeat", FeatName); }

    void UpdateNearbyTreasures(float DeltaTime) { NativeCall<void, float>(this, "AShooterPlayerController.UpdateNearbyTreasures", DeltaTime); }

    void UpdatePostProcessVolumes() { NativeCall<void>(this, "AShooterPlayerController.UpdatePostProcessVolumes"); }

    void UpdateRequestEquippedItemsQueue() { NativeCall<void>(this, "AShooterPlayerController.UpdateRequestEquippedItemsQueue"); }

    void UpdateRotation(float DeltaTime) { NativeCall<void, float>(this, "AShooterPlayerController.UpdateRotation", DeltaTime); }

    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); }

    bool UseTribeGroupRanks() { return NativeCall<bool>(this, "AShooterPlayerController.UseTribeGroupRanks"); }

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

    void ZoomInGPS() { NativeCall<void>(this, "AShooterPlayerController.ZoomInGPS"); }

    void ZoomInGPSStop() { NativeCall<void>(this, "AShooterPlayerController.ZoomInGPSStop"); }

    void ZoomOutGPS() { NativeCall<void>(this, "AShooterPlayerController.ZoomOutGPS"); }

    void ZoomOutGPSStop() { NativeCall<void>(this, "AShooterPlayerController.ZoomOutGPSStop"); }

    void CheckCheatsPassword(FString* pass) { NativeCall<void, FString*>(this, "AShooterPlayerController.CheckCheatsPassword", pass); }

    void CheckRequestSpectator(FString* InSpectatorPass) { NativeCall<void, FString*>(this, "AShooterPlayerController.CheckRequestSpectator", InSpectatorPass); }

    void ClientAbortTravel(unsigned int ServerID, unsigned __int64 ServerSteamId) { NativeCall<void, unsigned int, unsigned __int64>(this, "AShooterPlayerController.ClientAbortTravel", ServerID, ServerSteamId); }

    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, bool bForceText) { NativeCall<void, FVector_NetQuantize, int, int, bool>(this, "AShooterPlayerController.ClientAddFloatingDamageText", AtLocation, DamageAmount, FromTeamID, bForceText); }

    void ClientAddFloatingText(FVector_NetQuantize AtLocation, FString* FloatingTextString, FColor FloatingTextColor, float ScaleX, float ScaleY, float TextLifeSpan, FVector TextVelocity, float MinScale, float FadeInTime, float FadeOutTime, bool bForce) { NativeCall<void, FVector_NetQuantize, FString*, FColor, float, float, float, FVector, float, float, float, bool>(this, "AShooterPlayerController.ClientAddFloatingText", AtLocation, FloatingTextString, FloatingTextColor, ScaleX, ScaleY, TextLifeSpan, TextVelocity, MinScale, FadeInTime, FadeOutTime, bForce); }

    void ClientAddFolderToInventoryComponent(UPrimalInventoryComponent* forInventory, FString* NewCustomFolderName, int InventoryCompType) { NativeCall<void, UPrimalInventoryComponent*, FString*, int>(this, "AShooterPlayerController.ClientAddFolderToInventoryComponent", forInventory, NewCustomFolderName, InventoryCompType); }

    void ClientAfterServerChange() { NativeCall<void>(this, "AShooterPlayerController.ClientAfterServerChange"); }

    void ClientBeforeServerChange(FString* Message) { NativeCall<void, FString*>(this, "AShooterPlayerController.ClientBeforeServerChange", Message); }

    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 ClientDrawDebugSphere(TArray<FVector>* Loc, float Radius, int Segments, FColor DrawColor) { NativeCall<void, TArray<FVector>*, float, int, FColor>(this, "AShooterPlayerController.ClientDrawDebugSphere", Loc, Radius, Segments, DrawColor); }

    void ClientEndReceivingTribeLog() { NativeCall<void>(this, "AShooterPlayerController.ClientEndReceivingTribeLog"); }

    void ClientFailedRemoveSaddle() { NativeCall<void>(this, "AShooterPlayerController.ClientFailedRemoveSaddle"); }

    void ClientFeatActivationResult(TSubclassOf<APrimalBuff> FeatClass, int ActivationResult) { NativeCall<void, TSubclassOf<APrimalBuff>, int>(this, "AShooterPlayerController.ClientFeatActivationResult", FeatClass, ActivationResult); }

    void ClientFinishedReceivingActorItems(UPrimalInventoryComponent* forInventory, bool bEquippedItems) { NativeCall<void, UPrimalInventoryComponent*, bool>(this, "AShooterPlayerController.ClientFinishedReceivingActorItems", forInventory, bEquippedItems); }

    void ClientFinishedUseSlotTimeRemaining(UPrimalInventoryComponent* forInventory, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ClientFinishedUseSlotTimeRemaining", forInventory, itemID); }

    void ClientForceCacheTattooPainting() { NativeCall<void>(this, "AShooterPlayerController.ClientForceCacheTattooPainting"); }

    void ClientGetMessageOfTheDay(FString* Message) { NativeCall<void, FString*>(this, "AShooterPlayerController.ClientGetMessageOfTheDay", Message); }

    void ClientGiveFOW() { NativeCall<void>(this, "AShooterPlayerController.ClientGiveFOW"); }

    void ClientGotoMainMenuListSessions() { NativeCall<void>(this, "AShooterPlayerController.ClientGotoMainMenuListSessions"); }

    void ClientHUDNotificationTypeParams(int MessageType, int MessageType1, int MessageParam2, UObject* ObjectParam1, FString* StringParam1, float floatParam1) { NativeCall<void, int, int, int, UObject*, FString*, float>(this, "AShooterPlayerController.ClientHUDNotificationTypeParams", MessageType, MessageType1, MessageParam2, ObjectParam1, StringParam1, floatParam1); }

    void ClientInformHomeServerFull() { NativeCall<void>(this, "AShooterPlayerController.ClientInformHomeServerFull"); }

    void ClientInformNeedsNewHomeServer() { NativeCall<void>(this, "AShooterPlayerController.ClientInformNeedsNewHomeServer"); }

    void ClientInitHUDScenes() { NativeCall<void>(this, "AShooterPlayerController.ClientInitHUDScenes"); }

    void ClientInsertActorItem(UPrimalInventoryComponent* forInventory, FItemNetInfo itemInfo, FItemNetID InsertAfterItemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetInfo, FItemNetID>(this, "AShooterPlayerController.ClientInsertActorItem", forInventory, itemInfo, InsertAfterItemID); }

    void ClientJoinVivoxChannel(FString* JoinChannelVAT, FString* ChannelName, int AtlasChannelTypeAsInt, int AttenuationModelAsInt32, float MaxDistance, float MinDistance, float Rolloff) { NativeCall<void, FString*, FString*, int, int, float, float, float>(this, "AShooterPlayerController.ClientJoinVivoxChannel", JoinChannelVAT, ChannelName, AtlasChannelTypeAsInt, AttenuationModelAsInt32, MaxDistance, MinDistance, Rolloff); }

    void ClientLoginToVivox(FString* LoginVAT, FString* VivoxUsername) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ClientLoginToVivox", LoginVAT, VivoxUsername); }

    void ClientMarkSeamlessActors(TArray<AActor*>* ActorsWhichWillTravelSeamlessly, unsigned int DestServerId, EFastTravelType FastTravelType, float GridTravelToPosX, float GridTravelToPosY, float GridTravelToPosZ) { NativeCall<void, TArray<AActor*>*, unsigned int, EFastTravelType, float, float, float>(this, "AShooterPlayerController.ClientMarkSeamlessActors", ActorsWhichWillTravelSeamlessly, DestServerId, FastTravelType, GridTravelToPosX, GridTravelToPosY, GridTravelToPosZ); }

    void ClientNetReceiveMapEntities(TArray<FTribeEntity>* TribeEntities) { NativeCall<void, TArray<FTribeEntity>*>(this, "AShooterPlayerController.ClientNetReceiveMapEntities", TribeEntities); }

    void ClientNetReceiveTribeMembersFinished() { NativeCall<void>(this, "AShooterPlayerController.ClientNetReceiveTribeMembersFinished"); }

    void ClientNetReceiveTribeMembersLastOnlineAt(TArray<unsigned int>* MembersLastOnlineAt) { NativeCall<void, TArray<unsigned int>*>(this, "AShooterPlayerController.ClientNetReceiveTribeMembersLastOnlineAt", MembersLastOnlineAt); }

    void ClientNetReceiveTribeMembersPlayerDataID(TArray<unsigned int>* MembersPlayerDataID) { NativeCall<void, TArray<unsigned int>*>(this, "AShooterPlayerController.ClientNetReceiveTribeMembersPlayerDataID", MembersPlayerDataID); }

    void ClientNetReceiveTribeMembersPlayerName(TArray<FString>* MembersPlayerName) { NativeCall<void, TArray<FString>*>(this, "AShooterPlayerController.ClientNetReceiveTribeMembersPlayerName", MembersPlayerName); }

    void ClientNetReceiveTribeMembersRankGroupId(TArray<int>* MembersRankGroupId) { NativeCall<void, TArray<int>*>(this, "AShooterPlayerController.ClientNetReceiveTribeMembersRankGroupId", MembersRankGroupId); }

    void ClientNetReceiveTribeTribeAdmins(TArray<unsigned int>* TribeAdmins) { NativeCall<void, TArray<unsigned int>*>(this, "AShooterPlayerController.ClientNetReceiveTribeTribeAdmins", TribeAdmins); }

    void ClientNetStartReceivingMapEntities() { NativeCall<void>(this, "AShooterPlayerController.ClientNetStartReceivingMapEntities"); }

    void ClientNetStopReceivingMapEntities(int ServerMapEntitiesChangeID) { NativeCall<void, int>(this, "AShooterPlayerController.ClientNetStopReceivingMapEntities", ServerMapEntitiesChangeID); }

    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, TSubclassOf<APrimalDinoCharacter> DinoClass) { NativeCall<void, FString*, FString*, TSubclassOf<APrimalDinoCharacter>>(this, "AShooterPlayerController.ClientNotifyDinoDeath", DinoName, AttackerName, DinoClass); }

    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, AActor* DamageCauser) { NativeCall<void, APawn*, AActor*>(this, "AShooterPlayerController.ClientNotifyPlayerDeath", InstigatingPawn, DamageCauser); }

    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, FString* NameOveride, int Level) { NativeCall<void, TSubclassOf<APrimalDinoCharacter>, FString*, int>(this, "AShooterPlayerController.ClientNotifyTamedDino", DinoClass, NameOveride, Level); }

    void ClientNotifyTorpidityIncrease() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyTorpidityIncrease"); }

    void ClientNotifyTribeDataUpdated() { NativeCall<void>(this, "AShooterPlayerController.ClientNotifyTribeDataUpdated"); }

    void ClientNotifyTribeXP(float HowMuch) { NativeCall<void, float>(this, "AShooterPlayerController.ClientNotifyTribeXP", HowMuch); }

    void ClientNotifyUnlockHairStyleOrEmote(FName HairstyleOrEmoteName) { NativeCall<void, FName>(this, "AShooterPlayerController.ClientNotifyUnlockHairStyleOrEmote", HairstyleOrEmoteName); }

    void ClientNotifyUnlockedEngram(TSubclassOf<UPrimalEngramEntry> ItemClass) { NativeCall<void, TSubclassOf<UPrimalEngramEntry>>(this, "AShooterPlayerController.ClientNotifyUnlockedEngram", ItemClass); }

    void ClientNotifyUpgradedItem(UPrimalItem* UpgradedItem) { NativeCall<void, UPrimalItem*>(this, "AShooterPlayerController.ClientNotifyUpgradedItem", UpgradedItem); }

    void ClientOnFastTravelFailed() { NativeCall<void>(this, "AShooterPlayerController.ClientOnFastTravelFailed"); }

    void ClientOnReceivedCaptainOrder(ECaptainOrder::Type ReceivedOrder, FVector TargetLocation, bool bFromCaptain) { NativeCall<void, ECaptainOrder::Type, FVector, bool>(this, "AShooterPlayerController.ClientOnReceivedCaptainOrder", ReceivedOrder, TargetLocation, bFromCaptain); }

    void ClientOnTreasureCollected(FVector TreasureLocation) { NativeCall<void, FVector>(this, "AShooterPlayerController.ClientOnTreasureCollected", TreasureLocation); }

    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 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 ClientReceiveStructureCraftingStatItem(APrimalStructure* ForStructure, FItemNetInfo ItemInfo) { NativeCall<void, APrimalStructure*, FItemNetInfo>(this, "AShooterPlayerController.ClientReceiveStructureCraftingStatItem", ForStructure, ItemInfo); }

    void ClientReceiveTribeRankGroup(int GroupRankIndex) { NativeCall<void, int>(this, "AShooterPlayerController.ClientReceiveTribeRankGroup", GroupRankIndex); }

    void ClientRemoveActorItem(UPrimalInventoryComponent* forInventory, FItemNetID itemID, bool showHUDMessage) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, bool>(this, "AShooterPlayerController.ClientRemoveActorItem", forInventory, itemID, showHUDMessage); }

    void ClientRemovedItemFromSlot(UPrimalInventoryComponent* forInventory, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ClientRemovedItemFromSlot", forInventory, itemID); }

    void ClientReplicateTravelledObjects(TArray<UObject*>* Objects) { NativeCall<void, TArray<UObject*>*>(this, "AShooterPlayerController.ClientReplicateTravelledObjects", Objects); }

    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 ClientSetCheatStatus(bool bEnable) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientSetCheatStatus", bEnable); }

    void ClientSetControlRotation(FRotator NewRotation) { NativeCall<void, FRotator>(this, "AShooterPlayerController.ClientSetControlRotation", NewRotation); }

    void ClientSetSpectatorLocation(FVector NewLocation) { NativeCall<void, FVector>(this, "AShooterPlayerController.ClientSetSpectatorLocation", NewLocation); }

    void ClientShowCharacterCreationUI(bool bShowDownloadCharacter) { NativeCall<void, bool>(this, "AShooterPlayerController.ClientShowCharacterCreationUI", bShowDownloadCharacter); }

    void ClientShowPaintingUI(UObject* ObjectToPaint) { NativeCall<void, UObject*>(this, "AShooterPlayerController.ClientShowPaintingUI", ObjectToPaint); }

    void ClientShowSpawnUI(float Delay) { NativeCall<void, float>(this, "AShooterPlayerController.ClientShowSpawnUI", Delay); }

    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 ClientStartTravelling(unsigned int ServerID, unsigned __int64 ServerSteamId, unsigned __int64 TravelLog, bool UsingBattlEye) { NativeCall<void, unsigned int, unsigned __int64, unsigned __int64, bool>(this, "AShooterPlayerController.ClientStartTravelling", ServerID, ServerSteamId, TravelLog, UsingBattlEye); }

    void ClientStartingFastTravel() { NativeCall<void>(this, "AShooterPlayerController.ClientStartingFastTravel"); }

    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 ClientSyncCurrentSublevels_Finish() { NativeCall<void>(this, "AShooterPlayerController.ClientSyncCurrentSublevels_Finish"); }

    void ClientSyncCurrentSublevels_RecieveData(TArray<FTransformedSubLevel>* CurrentData) { NativeCall<void, TArray<FTransformedSubLevel>*>(this, "AShooterPlayerController.ClientSyncCurrentSublevels_RecieveData", CurrentData); }

    void ClientSyncCurrentSublevels_Start() { NativeCall<void>(this, "AShooterPlayerController.ClientSyncCurrentSublevels_Start"); }

    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 ClientUpdateGroupInfo(TArray<FOrderingGroupInfo>* GroupInfos, APrimalRaft* forRaft) { NativeCall<void, TArray<FOrderingGroupInfo>*, APrimalRaft*>(this, "AShooterPlayerController.ClientUpdateGroupInfo", GroupInfos, forRaft); }

    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 ClientUpdateItemSpoilingTimes(UPrimalInventoryComponent* forInventory, FItemNetID itemID, long double NextSpoilingTime, long double LastSpoilingTime) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, long double, long double>(this, "AShooterPlayerController.ClientUpdateItemSpoilingTimes", forInventory, itemID, NextSpoilingTime, LastSpoilingTime); }

    void ClientUpdateItemWeaponClipAmmo(UPrimalInventoryComponent* forInventory, FItemNetID itemID, int Ammo) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, int>(this, "AShooterPlayerController.ClientUpdateItemWeaponClipAmmo", forInventory, itemID, Ammo); }

    void ClientUpdateUnlockedSkills(TArray<TSubclassOf<UPrimalEngramEntry>>* NetUnlockedSkills) { NativeCall<void, TArray<TSubclassOf<UPrimalEngramEntry>>*>(this, "AShooterPlayerController.ClientUpdateUnlockedSkills", NetUnlockedSkills); }

    void ClientUsedActorItem(UPrimalInventoryComponent* forInventory, FItemNetID itemID) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID>(this, "AShooterPlayerController.ClientUsedActorItem", forInventory, itemID); }

    void Client_CaptainExtraActions(ECaptainOtherActions::Type RequestedAction, APrimalStructureSeating_DriverSeat* RequestedFromSeat, int CurrentValue, TSubclassOf<UPrimalItem> SelectedAmmoType) { NativeCall<void, ECaptainOtherActions::Type, APrimalStructureSeating_DriverSeat*, int, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerController.Client_CaptainExtraActions", RequestedAction, RequestedFromSeat, CurrentValue, SelectedAmmoType); }

    void ClosingViewOnlyInventory() { NativeCall<void>(this, "AShooterPlayerController.ClosingViewOnlyInventory"); }

    void DoServerCheckUnfreeze() { NativeCall<void>(this, "AShooterPlayerController.DoServerCheckUnfreeze"); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "AShooterPlayerController.GetPrivateStaticClass", Package); }

    void InitCharacterPainting(APrimalCharacter* Char, bool bForTattoo) { NativeCall<void, APrimalCharacter*, bool>(this, "AShooterPlayerController.InitCharacterPainting", Char, bForTattoo); }

    void NotifyTribeWarStatus(FString* EnemyTribeString, int StatusType) { NativeCall<void, FString*, int>(this, "AShooterPlayerController.NotifyTribeWarStatus", EnemyTribeString, StatusType); }

    void OnDisableSpectator() { NativeCall<void>(this, "AShooterPlayerController.OnDisableSpectator"); }

    void PlayHitMarkerCharacter(float InHitMarkerScale, bool InWasMeleeHit, APrimalCharacter* VictimCharacter) { NativeCall<void, float, bool, APrimalCharacter*>(this, "AShooterPlayerController.PlayHitMarkerCharacter", InHitMarkerScale, InWasMeleeHit, VictimCharacter); }

    void PlayHitMarkerCharacterAlly(float InHitMarkerScale, bool InWasMeleeHit) { NativeCall<void, float, bool>(this, "AShooterPlayerController.PlayHitMarkerCharacterAlly", InHitMarkerScale, InWasMeleeHit); }

    void PlayHitMarkerStructure(float InHitMarkerScale, bool InWasMeleeHit) { NativeCall<void, float, bool>(this, "AShooterPlayerController.PlayHitMarkerStructure", InHitMarkerScale, InWasMeleeHit); }

    void PlayHitMarkerStructureAlly(float InHitMarkerScale, bool InWasMeleeHit) { NativeCall<void, float, bool>(this, "AShooterPlayerController.PlayHitMarkerStructureAlly", InHitMarkerScale, InWasMeleeHit); }

    FString* PlayerCommand(FString* result, FString* TheCommand) { return NativeCall<FString*, FString*, FString*>(this, "AShooterPlayerController.PlayerCommand", result, TheCommand); }

    void RPCStayAlive() { NativeCall<void>(this, "AShooterPlayerController.RPCStayAlive"); }

    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 ServerAddItemToCustomFolder(UPrimalInventoryComponent* forInventory, FString* CFolderName, int InventoryCompType, FItemNetID ItemId) { NativeCall<void, UPrimalInventoryComponent*, FString*, int, FItemNetID>(this, "AShooterPlayerController.ServerAddItemToCustomFolder", forInventory, CFolderName, InventoryCompType, ItemId); }

    void ServerAddTribeMarker(FString* Name, float Coord1, float Coord2, FColor TextColor) { NativeCall<void, FString*, float, float, FColor>(this, "AShooterPlayerController.ServerAddTribeMarker", Name, Coord1, Coord2, TextColor); }

    void ServerAllowPlayerToJoinNoCheck(FString* PlayerId) { NativeCall<void, FString*>(this, "AShooterPlayerController.ServerAllowPlayerToJoinNoCheck", PlayerId); }

    void ServerBanPlayer(FString* PlayerSteamName, FString* PlayerSteamID) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ServerBanPlayer", PlayerSteamName, PlayerSteamID); }

    void ServerChangeHomeServer(unsigned int NewHomeServerId) { NativeCall<void, unsigned int>(this, "AShooterPlayerController.ServerChangeHomeServer", NewHomeServerId); }

    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 ServerDropFromRemoteInventory(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, bool bOnlyIfEquipped) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, bool>(this, "AShooterPlayerController.ServerDropFromRemoteInventory", inventoryComp, itemID, bOnlyIfEquipped); }

    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 ServerGetNotificationSettings() { NativeCall<void>(this, "AShooterPlayerController.ServerGetNotificationSettings"); }

    void ServerGetOriginalHairColor() { NativeCall<void>(this, "AShooterPlayerController.ServerGetOriginalHairColor"); }

    void ServerGlobalCommand(FString* Msg) { NativeCall<void, FString*>(this, "AShooterPlayerController.ServerGlobalCommand", Msg); }

    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 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 ServerReadMessageOFTheDay() { NativeCall<void>(this, "AShooterPlayerController.ServerReadMessageOFTheDay"); }

    void ServerReleaseSeatingStructure() { NativeCall<void>(this, "AShooterPlayerController.ServerReleaseSeatingStructure"); }

    void ServerRemovePassenger() { NativeCall<void>(this, "AShooterPlayerController.ServerRemovePassenger"); }

    void ServerRemovePawnItem(FItemNetID itemID, bool bSecondryAction, bool bOnlyIfEquipped) { NativeCall<void, FItemNetID, bool, bool>(this, "AShooterPlayerController.ServerRemovePawnItem", itemID, bSecondryAction, bOnlyIfEquipped); }

    void ServerRemoveTribeMarker(unsigned int MarkerID) { NativeCall<void, unsigned int>(this, "AShooterPlayerController.ServerRemoveTribeMarker", MarkerID); }

    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 ServerRequestActivateFeat(TSubclassOf<APrimalBuff> FeatClass) { NativeCall<void, TSubclassOf<APrimalBuff>>(this, "AShooterPlayerController.ServerRequestActivateFeat", FeatClass); }

    void ServerRequestActivateStationGroup(APrimalRaft* forRaft, int GroupIndex, bool bActivateForCaptain, bool bNewValue) { NativeCall<void, APrimalRaft*, int, bool, bool>(this, "AShooterPlayerController.ServerRequestActivateStationGroup", forRaft, GroupIndex, bActivateForCaptain, bNewValue); }

    void ServerRequestActorItems(UPrimalInventoryComponent* forInventory, bool bInventoryItems, bool bIsFirstSpawn, bool allowLocalController) { NativeCall<void, UPrimalInventoryComponent*, bool, bool, bool>(this, "AShooterPlayerController.ServerRequestActorItems", forInventory, bInventoryItems, bIsFirstSpawn, allowLocalController); }

    void ServerRequestDinoAncestors(APrimalDinoCharacter* ForDino) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterPlayerController.ServerRequestDinoAncestors", ForDino); }

    void ServerRequestDropAllItems(FString* CurrentCustomFolderFilter, FString* CurrentNameFilter) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerController.ServerRequestDropAllItems", CurrentCustomFolderFilter, CurrentNameFilter); }

    void ServerRequestFastTravelToShipBed(unsigned int FromBedID, unsigned int ToBedID) { NativeCall<void, unsigned int, unsigned int>(this, "AShooterPlayerController.ServerRequestFastTravelToShipBed", FromBedID, ToBedID); }

    void ServerRequestFullMapEntities(int ClientFullMapEntitiesChangeID, int ClientFullMapEntitiesCount) { NativeCall<void, int, int>(this, "AShooterPlayerController.ServerRequestFullMapEntities", ClientFullMapEntitiesChangeID, ClientFullMapEntitiesCount); }

    void ServerRequestInitiateSettlementWar(int requestIslandId, int requestStartTime, FItemNetID RequestUseItem) { NativeCall<void, int, int, FItemNetID>(this, "AShooterPlayerController.ServerRequestInitiateSettlementWar", requestIslandId, requestStartTime, RequestUseItem); }

    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 ServerRequestMyClientTribeData(unsigned int MyTribeMarkerVersion) { NativeCall<void, unsigned int>(this, "AShooterPlayerController.ServerRequestMyClientTribeData", MyTribeMarkerVersion); }

    void ServerRequestMyClientTribeMemberData() { NativeCall<void>(this, "AShooterPlayerController.ServerRequestMyClientTribeMemberData"); }

    void ServerRequestMyClientTribeMembersLastOnlineAt() { NativeCall<void>(this, "AShooterPlayerController.ServerRequestMyClientTribeMembersLastOnlineAt"); }

    void ServerRequestMyClientTribeRankGroup() { NativeCall<void>(this, "AShooterPlayerController.ServerRequestMyClientTribeRankGroup"); }

    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, TSubclassOf<APrimalStructure> DirectStructurePlacementClass) { NativeCall<void, int, FVector, FRotator, FRotator, APawn*, APrimalDinoCharacter*, FName, FItemNetID, bool, bool, bool, int, TSubclassOf<APrimalStructure>>(this, "AShooterPlayerController.ServerRequestPlaceStructure", StructureIndex, BuildLocation, BuildRotation, PlayerViewRotation, AttachToPawn, DinoCharacter, BoneName, PlaceUsingItemID, bSnapped, bIsCheat, bIsFlipped, SnapPointCycle, DirectStructurePlacementClass); }

    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(unsigned int spawnPointID, int spawnRegionIndex) { NativeCall<void, unsigned 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 ServerRequestStructureCraftingStatItem(APrimalStructure* ForStructure) { NativeCall<void, APrimalStructure*>(this, "AShooterPlayerController.ServerRequestStructureCraftingStatItem", ForStructure); }

    void ServerRequestTribeLog() { NativeCall<void>(this, "AShooterPlayerController.ServerRequestTribeLog"); }

    void ServerRequestUpdateGroupInfo(APrimalRaft* forRaft) { NativeCall<void, APrimalRaft*>(this, "AShooterPlayerController.ServerRequestUpdateGroupInfo", forRaft); }

    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 ServerSetAltHeld(bool bNewAltHeld) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerSetAltHeld", bNewAltHeld); }

    void ServerSetForceSingleWield(bool doSet) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerSetForceSingleWield", doSet); }

    void ServerSetNetIsCurrentlyFirstPerson(bool bIsCurrentlyFirstPerson) { NativeCall<void, bool>(this, "AShooterPlayerController.ServerSetNetIsCurrentlyFirstPerson", bIsCurrentlyFirstPerson); }

    void ServerSetPlayerForceSwitchAsPrimaryWeaponOnce() { NativeCall<void>(this, "AShooterPlayerController.ServerSetPlayerForceSwitchAsPrimaryWeaponOnce"); }

    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, int attackIndex, bool bIsUsingAltAnim) { NativeCall<void, AShooterWeapon*, int, bool>(this, "AShooterPlayerController.ServerStartWeaponFire", weapon, attackIndex, bIsUsingAltAnim); }

    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, int attackIndex, bool bIsUsingAltAnim) { NativeCall<void, AShooterWeapon*, int, bool>(this, "AShooterPlayerController.ServerStopWeaponFire", weapon, attackIndex, bIsUsingAltAnim); }

    void ServerSuccessfullyLoggedIntoVivox(FString* LoginSessionUserUri) { NativeCall<void, FString*>(this, "AShooterPlayerController.ServerSuccessfullyLoggedIntoVivox", LoginSessionUserUri); }

    void ServerToggleAllShipLadders() { NativeCall<void>(this, "AShooterPlayerController.ServerToggleAllShipLadders"); }

    void ServerToggleOpenAllActiveGunports() { NativeCall<void>(this, "AShooterPlayerController.ServerToggleOpenAllActiveGunports"); }

    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 ServerTransferToRemoteInventory(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, bool bAlsoTryToEqup, int requestedQuantity) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, bool, int>(this, "AShooterPlayerController.ServerTransferToRemoteInventory", inventoryComp, itemID, bAlsoTryToEqup, requestedQuantity); }

    void ServerTryRespec() { NativeCall<void>(this, "AShooterPlayerController.ServerTryRespec"); }

    void ServerTrySettingViewOnlyInventoryStatus() { NativeCall<void>(this, "AShooterPlayerController.ServerTrySettingViewOnlyInventoryStatus"); }

    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 ServerUpdateManualFireLocation(FVector TargetLocation) { NativeCall<void, FVector>(this, "AShooterPlayerController.ServerUpdateManualFireLocation", TargetLocation); }

    void ServerUpgradeItem(UPrimalInventoryComponent* inventoryComp, FItemNetID itemID, int ItemStatModifierIndexToUpgrade, int ItemStatGroupIndexToUpgrade) { NativeCall<void, UPrimalInventoryComponent*, FItemNetID, int, int>(this, "AShooterPlayerController.ServerUpgradeItem", inventoryComp, itemID, ItemStatModifierIndexToUpgrade, ItemStatGroupIndexToUpgrade); }

    void ServerUploadCharacterDataToArk(UPrimalInventoryComponent* inventoryComp) { NativeCall<void, UPrimalInventoryComponent*>(this, "AShooterPlayerController.ServerUploadCharacterDataToArk", inventoryComp); }

    void Server_CaptainExtraActions(ECaptainOtherActions::Type RequestedAction, APrimalStructureSeating_DriverSeat* RequestedFromSeat, int CurrentValue) { NativeCall<void, ECaptainOtherActions::Type, APrimalStructureSeating_DriverSeat*, int>(this, "AShooterPlayerController.Server_CaptainExtraActions", RequestedAction, RequestedFromSeat, CurrentValue); }

    void Server_SetShipSailRotation(float InSailRotation) { NativeCall<void, float>(this, "AShooterPlayerController.Server_SetShipSailRotation", InSailRotation); }

    void Server_SetShipSteeringInput(float InSteering) { NativeCall<void, float>(this, "AShooterPlayerController.Server_SetShipSteeringInput", InSteering); }

    void Server_SetShipThrottleTarget(float InThrottle) { NativeCall<void, float>(this, "AShooterPlayerController.Server_SetShipThrottleTarget", InThrottle); }

    void Server_SetWantsForcedMovement(int Direction) { NativeCall<void, int>(this, "AShooterPlayerController.Server_SetWantsForcedMovement", Direction); }

    void Server_UpdateRowing(float InRowingThrottle, float InRowingSteering, int FromSeatNumber) { NativeCall<void, float, float, int>(this, "AShooterPlayerController.Server_UpdateRowing", InRowingThrottle, InRowingSteering, FromSeatNumber); }

    static void StaticRegisterNativesAShooterPlayerController() { NativeCall<void>(nullptr, "AShooterPlayerController.StaticRegisterNativesAShooterPlayerController"); }

    AShooterPlayerState* GetShooterPlayerState() { return NativeCall<AShooterPlayerState*>(this, "AShooterPlayerController.GetShooterPlayerState"); }

    AShooterHUD* GetShooterHUD() { return NativeCall<AShooterHUD*>(this, "AShooterPlayerController.GetShooterHUD"); }

};


struct ACharacter : APawn

{

    TSubobjectPtr<UCharacterMovementComponent>& CharacterMovementField() { return *GetNativePointerField<TSubobjectPtr<UCharacterMovementComponent>*>(this, "ACharacter.CharacterMovement"); }

    unsigned __int16& LastMoveOnlyRotationPitchField() { return *GetNativePointerField<unsigned __int16*>(this, "ACharacter.LastMoveOnlyRotationPitch"); }

    unsigned __int16& LastMoveOnlyRotationYawField() { return *GetNativePointerField<unsigned __int16*>(this, "ACharacter.LastMoveOnlyRotationYaw"); }

    unsigned __int16& LastReplicatedMoveOnlyRotationPitchField() { return *GetNativePointerField<unsigned __int16*>(this, "ACharacter.LastReplicatedMoveOnlyRotationPitch"); }

    unsigned __int16& LastReplicatedMoveOnlyRotationYawField() { return *GetNativePointerField<unsigned __int16*>(this, "ACharacter.LastReplicatedMoveOnlyRotationYaw"); }

    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"); }

    FDodgeMovementInfo& DodgingMovementInfoField() { return *GetNativePointerField<FDodgeMovementInfo*>(this, "ACharacter.DodgingMovementInfo"); }

    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"); }

    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> bCanEverDodge() { return { this, "ACharacter.bCanEverDodge" }; }

    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> bRelativeBaseUsePitchAndRoll() { return { this, "ACharacter.bRelativeBaseUsePitchAndRoll" }; }

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

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

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

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


    // Functions


    UPrimitiveComponent* GetMovementBase() { return NativeCall<UPrimitiveComponent*>(this, "ACharacter.GetMovementBase"); }

    bool IsJumping() { return NativeCall<bool>(this, "ACharacter.IsJumping"); }

    bool NotifyLanded(FHitResult* Hit) { return NativeCall<bool, FHitResult*>(this, "ACharacter.NotifyLanded", Hit); }

    bool ShouldOverrideNewFallVelocity() { return NativeCall<bool>(this, "ACharacter.ShouldOverrideNewFallVelocity"); }

    bool ShouldOverrideSwimmingVelocity() { return NativeCall<bool>(this, "ACharacter.ShouldOverrideSwimmingVelocity"); }

    bool ShouldOverrideWalkingVelocity() { return NativeCall<bool>(this, "ACharacter.ShouldOverrideWalkingVelocity"); }

    void SetLastMovementDesiredRotation(FRotator* InRotation) { NativeCall<void, FRotator*>(this, "ACharacter.SetLastMovementDesiredRotation", InRotation); }

    bool AllowMovementMode(EMovementMode NewMovementMode, char NewCustomMode) { return NativeCall<bool, EMovementMode, char>(this, "ACharacter.AllowMovementMode", NewMovementMode, NewCustomMode); }

    void ApplyDamageMomentum(float DamageTaken, FDamageEvent* DamageEvent, APawn* PawnInstigator, AActor* DamageCauser) { NativeCall<void, float, FDamageEvent*, APawn*, AActor*>(this, "ACharacter.ApplyDamageMomentum", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }

    void ApplyWorldOffset(FVector* InOffset, bool bWorldShift) { NativeCall<void, FVector*, bool>(this, "ACharacter.ApplyWorldOffset", InOffset, bWorldShift); }

    USoundBase* BPOverrideCharacterSound_Implementation(USoundBase* SoundIn) { return NativeCall<USoundBase*, USoundBase*>(this, "ACharacter.BPOverrideCharacterSound_Implementation", SoundIn); }

    void BaseChange() { NativeCall<void>(this, "ACharacter.BaseChange"); }

    bool CanCrouch() { return NativeCall<bool>(this, "ACharacter.CanCrouch"); }

    bool CanDodge() { return NativeCall<bool>(this, "ACharacter.CanDodge"); }

    bool CanJump() { return NativeCall<bool>(this, "ACharacter.CanJump"); }

    bool CanJumpInternal_Implementation() { return NativeCall<bool>(this, "ACharacter.CanJumpInternal_Implementation"); }

    bool CanProne() { return NativeCall<bool>(this, "ACharacter.CanProne"); }

    void CheckJumpInput(float DeltaTime) { NativeCall<void, float>(this, "ACharacter.CheckJumpInput", DeltaTime); }

    void ClearCrossLevelReferences() { NativeCall<void>(this, "ACharacter.ClearCrossLevelReferences"); }

    void ClearJumpInput() { NativeCall<void>(this, "ACharacter.ClearJumpInput"); }

    void ClientCheatFly_Implementation() { NativeCall<void>(this, "ACharacter.ClientCheatFly_Implementation"); }

    void ClientCheatGhost_Implementation() { NativeCall<void>(this, "ACharacter.ClientCheatGhost_Implementation"); }

    void ClientCheatWalk_Implementation() { NativeCall<void>(this, "ACharacter.ClientCheatWalk_Implementation"); }

    void Crouch(bool bClientSimulation) { NativeCall<void, bool>(this, "ACharacter.Crouch", bClientSimulation); }

    bool DoJump(bool bReplayingMoves) { return NativeCall<bool, bool>(this, "ACharacter.DoJump", bReplayingMoves); }

    UActorComponent* FindComponentByClass(TSubclassOf<UActorComponent> ComponentClass) { return NativeCall<UActorComponent*, TSubclassOf<UActorComponent>>(this, "ACharacter.FindComponentByClass", ComponentClass); }

    UAnimMontage* GetCurrentMontage() { return NativeCall<UAnimMontage*>(this, "ACharacter.GetCurrentMontage"); }

    float GetDefaultHalfHeight() { return NativeCall<float>(this, "ACharacter.GetDefaultHalfHeight"); }

    float GetJumpMaxHoldTime() { return NativeCall<float>(this, "ACharacter.GetJumpMaxHoldTime"); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "ACharacter.GetLifetimeReplicatedProps", OutLifetimeProps); }

    void GetSimpleCollisionCylinder(float* CollisionRadius, float* CollisionHalfHeight) { NativeCall<void, float*, float*>(this, "ACharacter.GetSimpleCollisionCylinder", CollisionRadius, CollisionHalfHeight); }

    bool IsBasedOnDynamicActor() { return NativeCall<bool>(this, "ACharacter.IsBasedOnDynamicActor"); }

    bool IsComponentTickDelegated(UActorComponent* Component) { return NativeCall<bool, UActorComponent*>(this, "ACharacter.IsComponentTickDelegated", Component); }

    bool IsGamePlayRelevant() { return NativeCall<bool>(this, "ACharacter.IsGamePlayRelevant"); }

    void Jump() { NativeCall<void>(this, "ACharacter.Jump"); }

    void Landed(FHitResult* Hit) { NativeCall<void, FHitResult*>(this, "ACharacter.Landed", Hit); }

    void LaunchCharacter(FVector LaunchVelocity, bool bXYOverride, bool bZOverride) { NativeCall<void, FVector, bool, bool>(this, "ACharacter.LaunchCharacter", LaunchVelocity, bXYOverride, bZOverride); }

    void NetTeleportSucceeded_Implementation(FVector ToLoc, FRotator ToRot) { NativeCall<void, FVector, FRotator>(this, "ACharacter.NetTeleportSucceeded_Implementation", ToLoc, ToRot); }

    void OnEndCrouch(float HeightAdjust, float ScaledHeightAdjust) { NativeCall<void, float, float>(this, "ACharacter.OnEndCrouch", HeightAdjust, ScaledHeightAdjust); }

    void OnMovementModeChanged(EMovementMode PrevMovementMode, char PrevCustomMode) { NativeCall<void, EMovementMode, char>(this, "ACharacter.OnMovementModeChanged", PrevMovementMode, PrevCustomMode); }

    void OnRep_DodgingMovementInfo() { NativeCall<void>(this, "ACharacter.OnRep_DodgingMovementInfo"); }

    void OnRep_IsCrouched() { NativeCall<void>(this, "ACharacter.OnRep_IsCrouched"); }

    void OnRep_IsProne() { NativeCall<void>(this, "ACharacter.OnRep_IsProne"); }

    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 OnStartCrouch(float HeightAdjust, float ScaledHeightAdjust) { NativeCall<void, float, float>(this, "ACharacter.OnStartCrouch", HeightAdjust, ScaledHeightAdjust); }

    void PawnClientRestart() { NativeCall<void>(this, "ACharacter.PawnClientRestart"); }

    float PlayAnimMontage(UAnimMontage* AnimMontage, float InPlayRate, FName StartSectionName, bool bForceTickPoseAndServerUpdateMesh, bool bForceTickPoseOnServer) { return NativeCall<float, UAnimMontage*, float, FName, bool, bool>(this, "ACharacter.PlayAnimMontage", AnimMontage, InPlayRate, StartSectionName, bForceTickPoseAndServerUpdateMesh, bForceTickPoseOnServer); }

    void PossessedBy(AController* NewController) { NativeCall<void, AController*>(this, "ACharacter.PossessedBy", NewController); }

    void PostInitializeComponents() { NativeCall<void>(this, "ACharacter.PostInitializeComponents"); }

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

    void PostNetReceiveLocationAndRotation() { NativeCall<void>(this, "ACharacter.PostNetReceiveLocationAndRotation"); }

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

    bool PreventMovementMode(EMovementMode NewMovementMode, char NewCustomMode) { return NativeCall<bool, EMovementMode, char>(this, "ACharacter.PreventMovementMode", NewMovementMode, NewCustomMode); }

    void Prone(bool bClientSimulation) { NativeCall<void, bool>(this, "ACharacter.Prone", bClientSimulation); }

    void RecalculateBaseEyeHeight() { NativeCall<void>(this, "ACharacter.RecalculateBaseEyeHeight"); }

    void Restart() { NativeCall<void>(this, "ACharacter.Restart"); }

    void SetBase(UPrimitiveComponent* NewBaseComponent, FName BoneName, bool bNotifyPawn) { NativeCall<void, UPrimitiveComponent*, FName, bool>(this, "ACharacter.SetBase", NewBaseComponent, BoneName, bNotifyPawn); }

    bool ShouldNotifyLanded(FHitResult* Hit) { return NativeCall<bool, FHitResult*>(this, "ACharacter.ShouldNotifyLanded", Hit); }

    bool ShouldReplicateRotPitch() { return NativeCall<bool>(this, "ACharacter.ShouldReplicateRotPitch"); }

    bool ShouldUseWaveLocking(bool bForceCheck) { return NativeCall<bool, bool>(this, "ACharacter.ShouldUseWaveLocking", bForceCheck); }

    bool SimpleTeleportTo(FVector* DestLocation, FRotator* DestRotation) { return NativeCall<bool, FVector*, FRotator*>(this, "ACharacter.SimpleTeleportTo", DestLocation, DestRotation); }

    void StartDodging(FVector InDodgingVelocity, bool bClientSimulation) { NativeCall<void, FVector, bool>(this, "ACharacter.StartDodging", InDodgingVelocity, bClientSimulation); }

    void StopAnimMontage(UAnimMontage* AnimMontage) { NativeCall<void, UAnimMontage*>(this, "ACharacter.StopAnimMontage", AnimMontage); }

    void StopDodging(bool bClientSimulation) { NativeCall<void, bool>(this, "ACharacter.StopDodging", bClientSimulation); }

    void StopJumping() { NativeCall<void>(this, "ACharacter.StopJumping"); }

    void TeleportSucceeded(bool bIsATest, bool bSimpleTeleport) { NativeCall<void, bool, bool>(this, "ACharacter.TeleportSucceeded", bIsATest, bSimpleTeleport); }

    bool TeleportTo(FVector* DestLocation, FRotator* DestRotation, bool bIsATest, bool bNoCheck) { return NativeCall<bool, FVector*, FRotator*, bool, bool>(this, "ACharacter.TeleportTo", DestLocation, DestRotation, bIsATest, bNoCheck); }

    void TickFromBaseWhenAttachedToParent() { NativeCall<void>(this, "ACharacter.TickFromBaseWhenAttachedToParent"); }

    void TornOff() { NativeCall<void>(this, "ACharacter.TornOff"); }

    void TurnOff() { NativeCall<void>(this, "ACharacter.TurnOff"); }

    void UnCrouch(bool bClientSimulation) { NativeCall<void, bool>(this, "ACharacter.UnCrouch", bClientSimulation); }

    void UnPossessed() { NativeCall<void>(this, "ACharacter.UnPossessed"); }

    void UnProne(bool bClientSimulation) { NativeCall<void, bool>(this, "ACharacter.UnProne", bClientSimulation); }

    void UpdateSimulatedPosition(FVector* NewLocation, FRotator* NewRotation) { NativeCall<void, FVector*, FRotator*>(this, "ACharacter.UpdateSimulatedPosition", NewLocation, NewRotation); }

    bool BP_PreventMovementMode(EMovementMode newMovementMode, char newCustomMode) { return NativeCall<bool, EMovementMode, char>(this, "ACharacter.BP_PreventMovementMode", newMovementMode, newCustomMode); }

    bool CanJumpInternal() { return NativeCall<bool>(this, "ACharacter.CanJumpInternal"); }

    void ClientCheatFly() { NativeCall<void>(this, "ACharacter.ClientCheatFly"); }

    void ClientCheatGhost() { NativeCall<void>(this, "ACharacter.ClientCheatGhost"); }

    void ClientCheatWalk() { NativeCall<void>(this, "ACharacter.ClientCheatWalk"); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "ACharacter.GetPrivateStaticClass", Package); }

    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 NetTeleportSucceeded(FVector ToLoc, FRotator ToRot) { NativeCall<void, FVector, FRotator>(this, "ACharacter.NetTeleportSucceeded", ToLoc, ToRot); }

    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"); }

    static void StaticRegisterNativesACharacter() { NativeCall<void>(nullptr, "ACharacter.StaticRegisterNativesACharacter"); }

};


struct APrimalCharacter : ACharacter

{

    TSubclassOf<UPrimalHarvestingComponent>& DeathHarvestingComponentField() { return *GetNativePointerField<TSubclassOf<UPrimalHarvestingComponent>*>(this, "APrimalCharacter.DeathHarvestingComponent"); }

    UPrimalHarvestingComponent* MyDeathHarvestingComponentField() { return *GetNativePointerField<UPrimalHarvestingComponent**>(this, "APrimalCharacter.MyDeathHarvestingComponentField"); }

    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& 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"); }

    long double& ForceFootCacheUntilTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.ForceFootCacheUntilTime"); }

    UAnimMontage* JumpAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalCharacter.JumpAnim"); }

    UAnimMontage* LandedAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalCharacter.LandedAnim"); }

    UAnimMontage* HurtAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalCharacter.HurtAnim"); }

    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"); }

    TArray<APrimalBuff*> SeamlessTravelBuffsField() { return *GetNativePointerField<TArray<APrimalBuff*>*>(this, "APrimalCharacter.SeamlessTravelBuffs"); }

    EWeaponAttackInput::Type& LastShieldBlockingInputPressedField() { return *GetNativePointerField<EWeaponAttackInput::Type*>(this, "APrimalCharacter.LastShieldBlockingInputPressed"); }

    EWeaponAttackInput::Type& LastInputPressedField() { return *GetNativePointerField<EWeaponAttackInput::Type*>(this, "APrimalCharacter.LastInputPressed"); }

    long double& LastTimePressedInputField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastTimePressedInput"); }

    float& currentStaggeringTimeField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.currentStaggeringTime"); }

    long double& lastTimeStaggeredField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.lastTimeStaggered"); }

    FPrimalCharacterNotifyAttackStarted& NotifyAttackStartedField() { return *GetNativePointerField<FPrimalCharacterNotifyAttackStarted*>(this, "APrimalCharacter.NotifyAttackStarted"); }

    FPrimalCharacterNotifyAttackEnded& NotifyAttackEndedField() { return *GetNativePointerField<FPrimalCharacterNotifyAttackEnded*>(this, "APrimalCharacter.NotifyAttackEnded"); }

    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"); }

    TSubclassOf<UPrimalItem>& PoopItemClassField() { return *GetNativePointerField<TSubclassOf<UPrimalItem>*>(this, "APrimalCharacter.PoopItemClass"); }

    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"); }

    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"); }

    TArray<TSubclassOf<APrimalStructure>>& ImmobilizationTrapsToIgnoreField() { return *GetNativePointerField<TArray<TSubclassOf<APrimalStructure>>*>(this, "APrimalCharacter.ImmobilizationTrapsToIgnore"); }

    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"); }

    FVector& DragOffsetField() { return *GetNativePointerField<FVector*>(this, "APrimalCharacter.DragOffset"); }

    AShooterCharacter* LastGrapHookPullingOwnerField() { return *GetNativePointerField<AShooterCharacter**>(this, "APrimalCharacter.LastGrapHookPullingOwner"); }

    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"); }

    UAnimMontage* DeathAnimFromBackField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalCharacter.DeathAnimFromBack"); }

    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"); }

    int& ServerLastFrameCounterChangeField() { return *GetNativePointerField<int*>(this, "APrimalCharacter.ServerLastFrameCounterChange"); }

    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"); }

    UStaticMesh* BolaStaticMeshOverrideField() { return *GetNativePointerField<UStaticMesh**>(this, "APrimalCharacter.BolaStaticMeshOverride"); }

    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"); }

    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"); }

    UPrimalInventoryComponent* MyInventoryComponentField() { return *GetNativePointerField<UPrimalInventoryComponent**>(this, "APrimalCharacter.MyInventoryComponent"); }

    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"); }

    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"); }

    FSeamlessIslandInfo* MyIslandInfoField() { return *GetNativePointerField<FSeamlessIslandInfo**>(this, "APrimalCharacter.MyIslandInfo"); }

    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"); }

    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"); }

    TArray<TSubclassOf<APrimalBuff>>& PossessionBuffsField() { return *GetNativePointerField<TArray<TSubclassOf<APrimalBuff>>*>(this, "APrimalCharacter.PossessionBuffs"); }

    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"); }

    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"); }

    float& ExtraMaxSpeedModifierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ExtraMaxSpeedModifier"); }

    float& TamedDinoCallOutRangeField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.TamedDinoCallOutRange"); }

    long double& LastMyRaftTakeDamageFromEnemyTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastMyRaftTakeDamageFromEnemyTime"); }

    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& ReplicatedMaxInventoryWeightField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ReplicatedMaxInventoryWeight"); }

    float& CharacterDamageImpulseMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.CharacterDamageImpulseMultiplier"); }

    float& DefendingInterruptLevelMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.DefendingInterruptLevelMultiplier"); }

    long double& ForceCheckPushThroughWallsTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.ForceCheckPushThroughWallsTime"); }

    long double& LastStartedBasingOnRaftTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastStartedBasingOnRaftTime"); }

    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"); }

    long double& LastLocalHitMarkerTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastLocalHitMarkerTime"); }

    TArray<TSubclassOf<APrimalBuff>>& PreventBuffClassesField() { return *GetNativePointerField<TArray<TSubclassOf<APrimalBuff>>*>(this, "APrimalCharacter.PreventBuffClasses"); }

    long double& DisableUnBasingUntilField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.DisableUnBasingUntil"); }

    long double& TimeStartedTargetingField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.TimeStartedTargeting"); }

    TWeakObjectPtr<APrimalDinoCharacter>& RidingDinoField() { return *GetNativePointerField<TWeakObjectPtr<APrimalDinoCharacter>*>(this, "APrimalCharacter.RidingDino"); }

    FName& WeaponAttachPointField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.WeaponAttachPoint"); }

    float& TargetingTimeField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.TargetingTime"); }

    float& RecentHurtAmountField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.RecentHurtAmount"); }

    long double& LocalLastHurtTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LocalLastHurtTime"); }

    UAnimMontage* ShieldCoverAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalCharacter.ShieldCoverAnim"); }

    UAnimMontage* ShieldCrouchedCoverAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalCharacter.ShieldCrouchedCoverAnim"); }

    UAnimSequence* DefaultShieldAnimationField() { return *GetNativePointerField<UAnimSequence**>(this, "APrimalCharacter.DefaultShieldAnimation"); }

    TWeakObjectPtr<APrimalStructureSeating>& SeatingStructureField() { return *GetNativePointerField<TWeakObjectPtr<APrimalStructureSeating>*>(this, "APrimalCharacter.SeatingStructure"); }

    float& SeatedOnShipDrawDistanceMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.SeatedOnShipDrawDistanceMultiplier"); }

    int& SeatingStructureSeatNumberField() { return *GetNativePointerField<int*>(this, "APrimalCharacter.SeatingStructureSeatNumber"); }

    long double& LastReleaseSeatingStructureTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastReleaseSeatingStructureTime"); }

    AShooterWeapon* CurrentWeaponField() { return *GetNativePointerField<AShooterWeapon**>(this, "APrimalCharacter.CurrentWeapon"); }

    long double& StartedRidingTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.StartedRidingTime"); }

    long double& StopRidingTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.StopRidingTime"); }

    long double& LocalLastViewingInventoryTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LocalLastViewingInventoryTime"); }

    TArray<TEnumAsByte<enum EWeaponAttackInput::Type>>& ShieldCoverInputsField() { return *GetNativePointerField<TArray<TEnumAsByte<enum EWeaponAttackInput::Type>>*>(this, "APrimalCharacter.ShieldCoverInputs"); }

    long double& TimeForNextValidShieldRaiseInField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.TimeForNextValidShieldRaiseIn"); }

    long double& TimeForNextValidShieldRaiseOutField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.TimeForNextValidShieldRaiseOut"); }

    float& Teleport_OntoRaft_CheckRadiusField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.Teleport_OntoRaft_CheckRadius"); }

    float& Teleport_OntoRaft_TraceIntervalDistOverrideField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.Teleport_OntoRaft_TraceIntervalDistOverride"); }

    int& Teleport_OntoRaft_MaxTraceCountField() { return *GetNativePointerField<int*>(this, "APrimalCharacter.Teleport_OntoRaft_MaxTraceCount"); }

    float& Teleport_OntoRaft_AllowedTopDeckZDistField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.Teleport_OntoRaft_AllowedTopDeckZDist"); }

    TSubclassOf<AShooterWeapon>& DefaultWeaponField() { return *GetNativePointerField<TSubclassOf<AShooterWeapon>*>(this, "APrimalCharacter.DefaultWeapon"); }

    FName& PreviousAwakeCollisionProfileNameField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.PreviousAwakeCollisionProfileName"); }

    UAnimSequence* DefaultSeatingAnimationField() { return *GetNativePointerField<UAnimSequence**>(this, "APrimalCharacter.DefaultSeatingAnimation"); }

    float& ServerSeatedViewRotationYawField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ServerSeatedViewRotationYaw"); }

    float& ServerSeatedViewRotationPitchField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.ServerSeatedViewRotationPitch"); }

    FName& PreAttachToSeatingStructureCollisionProfileNameField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.PreAttachToSeatingStructureCollisionProfileName"); }

    UAnimMontage* FireBallistaAnimationField() { return *GetNativePointerField<UAnimMontage**>(this, "APrimalCharacter.FireBallistaAnimation"); }

    TWeakObjectPtr<UPrimitiveComponent>& LastMovementBaseField() { return *GetNativePointerField<TWeakObjectPtr<UPrimitiveComponent>*>(this, "APrimalCharacter.LastMovementBase"); }

    float& StartWaveLockingThresholdField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.StartWaveLockingThreshold"); }

    long double& LastBasedOnRaftTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.LastBasedOnRaftTime"); }

    TWeakObjectPtr<APrimalDinoCharacter>& LastBasedOnRaftField() { return *GetNativePointerField<TWeakObjectPtr<APrimalDinoCharacter>*>(this, "APrimalCharacter.LastBasedOnRaft"); }

    FVector& MeleeLockOnPointOffsetField() { return *GetNativePointerField<FVector*>(this, "APrimalCharacter.MeleeLockOnPointOffset"); }

    TArray<FAssetMatcher>& DamageTypeHurtAnimOverridesField() { return *GetNativePointerField<TArray<FAssetMatcher>*>(this, "APrimalCharacter.DamageTypeHurtAnimOverrides"); }

    float& LastBasedOnRaftOpenWaterSpoilingMultField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.LastBasedOnRaftOpenWaterSpoilingMult"); }

    long double& NextRefreshedIslandInfoTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.NextRefreshedIslandInfoTime"); }

    FVector2D& LastRefreshedIslandInfoLocField() { return *GetNativePointerField<FVector2D*>(this, "APrimalCharacter.LastRefreshedIslandInfoLoc"); }

    float& LevelForMaxAIDifficultyField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.LevelForMaxAIDifficulty"); }

    TEnumAsByte<enum EMovementMode>& LastServerMovementModeField() { return *GetNativePointerField<TEnumAsByte<enum EMovementMode>*>(this, "APrimalCharacter.LastServerMovementMode"); }

    FName& WeaponAttachPointSecondaryField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.WeaponAttachPointSecondary"); }

    FItemNetID& NextWeaponItemIDSecondaryField() { return *GetNativePointerField<FItemNetID*>(this, "APrimalCharacter.NextWeaponItemIDSecondary"); }

    FItemNetID& NextWeaponItemIDPrimaryField() { return *GetNativePointerField<FItemNetID*>(this, "APrimalCharacter.NextWeaponItemIDPrimary"); }

    long double& CharacterDiedAtTimeField() { return *GetNativePointerField<long double*>(this, "APrimalCharacter.CharacterDiedAtTime"); }

    TSubclassOf<APrimalBuff>& PostFeatStaminaRecoveryCooldownDebuffField() { return *GetNativePointerField<TSubclassOf<APrimalBuff>*>(this, "APrimalCharacter.PostFeatStaminaRecoveryCooldownDebuff"); }

    float& CannonReloadMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.CannonReloadMultiplier"); }

    TArray<UClass*> WeaponBreakClassesField() { return *GetNativePointerField<TArray<UClass*>*>(this, "APrimalCharacter.WeaponBreakClasses"); }

    TArray<float>& WeaponBreakLifesField() { return *GetNativePointerField<TArray<float>*>(this, "APrimalCharacter.WeaponBreakLifes"); }

    FName& NonDediOverrideMeshCollisionProfileNameField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.NonDediOverrideMeshCollisionProfileName"); }

    FName& NonDediOverrideCapsuleCollisionProfileNameField() { return *GetNativePointerField<FName*>(this, "APrimalCharacter.NonDediOverrideCapsuleCollisionProfileName"); }

    bool& bIgnoreSimulatedRotationField() { return *GetNativePointerField<bool*>(this, "APrimalCharacter.bIgnoreSimulatedRotation"); }

    float& SimulatedInterLocSpeedField() { return *GetNativePointerField<float*>(this, "APrimalCharacter.SimulatedInterLocSpeed"); }

    FVector& SimulatedInterpToLocField() { return *GetNativePointerField<FVector*>(this, "APrimalCharacter.SimulatedInterpToLoc"); }


    // Bit fields


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

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

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

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

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

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

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

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

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

    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> 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> 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> 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> 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> 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> 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> 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> 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> bPreventHurtAnim() { return { this, "APrimalCharacter.bPreventHurtAnim" }; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


    // Functions


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

    UObject* GetUObjectInterfaceTargetableInterface() { return NativeCall<UObject*>(this, "APrimalCharacter.GetUObjectInterfaceTargetableInterface"); }

    void AdjustDamage(float* Damage, FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { NativeCall<void, float*, FDamageEvent*, AController*, AActor*>(this, "APrimalCharacter.AdjustDamage", Damage, DamageEvent, EventInstigator, DamageCauser); }

    bool AllowColoringBy(APlayerController* ForPC, UObject* anItem) { return NativeCall<bool, APlayerController*, UObject*>(this, "APrimalCharacter.AllowColoringBy", ForPC, anItem); }

    bool AllowFirstPerson() { return NativeCall<bool>(this, "APrimalCharacter.AllowFirstPerson"); }

    bool AllowHurtAnimation() { return NativeCall<bool>(this, "APrimalCharacter.AllowHurtAnimation"); }

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

    FVector* AnimGraphGetInterpolatedLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APrimalCharacter.AnimGraphGetInterpolatedLocation", result); }

    bool AnimationPreventsInput(bool bTestingForFirstPerson) { return NativeCall<bool, bool>(this, "APrimalCharacter.AnimationPreventsInput", bTestingForFirstPerson); }

    void ApplyDamageMomentum(float DamageTaken, FDamageEvent* DamageEvent, APawn* PawnInstigator, AActor* DamageCauser) { NativeCall<void, float, FDamageEvent*, APawn*, AActor*>(this, "APrimalCharacter.ApplyDamageMomentum", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }

    void AttachGPSTransponder(APrimalStructureExplosiveTransGPS* Transponder) { NativeCall<void, APrimalStructureExplosiveTransGPS*>(this, "APrimalCharacter.AttachGPSTransponder", Transponder); }

    AActor* BPGetAimedActor(FHitResult* outHitResult, ECollisionChannel CollisionChannel, float MaxDistanceOverride, float CheckRadius, bool bForceUseCameraLocation, bool bForceUpdateAimedActors) { return NativeCall<AActor*, FHitResult*, ECollisionChannel, float, float, bool, bool>(this, "APrimalCharacter.BPGetAimedActor", outHitResult, CollisionChannel, MaxDistanceOverride, CheckRadius, bForceUseCameraLocation, bForceUpdateAimedActors); }

    bool BPIsBasedOnDynamicActor() { return NativeCall<bool>(this, "APrimalCharacter.BPIsBasedOnDynamicActor"); }

    bool IsGameInputAllowed() { return NativeCall<bool>(this, "APrimalCharacter.IsGameInputAllowed"); }

    bool BPIsGameplayInputAllowed(bool bCheckForFullBodyAnimations, UAnimMontage* IgnoreFullBodyMontage) { return NativeCall<bool, bool, UAnimMontage*>(this, "APrimalCharacter.BPIsGameplayInputAllowed", bCheckForFullBodyAnimations, IgnoreFullBodyMontage); }

    float BPModifyFOV_Implementation(float FOVIn) { return NativeCall<float, float>(this, "APrimalCharacter.BPModifyFOV_Implementation", FOVIn); }

    void BPNetAddCharacterMovementImpulse(FVector Impulse, bool bVelChange, float ImpulseExponent, bool bSetNewMovementMode, EMovementMode NewMovementMode, bool bOverrideMaxImpulseZ) { NativeCall<void, FVector, bool, float, bool, EMovementMode, bool>(this, "APrimalCharacter.BPNetAddCharacterMovementImpulse", Impulse, bVelChange, ImpulseExponent, bSetNewMovementMode, NewMovementMode, bOverrideMaxImpulseZ); }

    void BPNetSetCharacterMovementVelocity(bool bSetNewVelocity, FVector NewVelocity, bool bSetNewMovementMode, EMovementMode NewMovementMode) { NativeCall<void, bool, FVector, bool, EMovementMode>(this, "APrimalCharacter.BPNetSetCharacterMovementVelocity", bSetNewVelocity, NewVelocity, bSetNewMovementMode, NewMovementMode); }

    float BP_GetMaxSpeedModifier() { return NativeCall<float>(this, "APrimalCharacter.BP_GetMaxSpeedModifier"); }

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

    void BlueprintIsSwitchingWeapons(bool* bIsSwitchingWeapons, bool* bIsUnequipping) { NativeCall<void, bool*, bool*>(this, "APrimalCharacter.BlueprintIsSwitchingWeapons", bIsSwitchingWeapons, bIsUnequipping); }

    bool CanBaseOnActorWhileSwimming(AActor* BaseActor, FHitResult* HitInfo) { return NativeCall<bool, AActor*, FHitResult*>(this, "APrimalCharacter.CanBaseOnActorWhileSwimming", BaseActor, HitInfo); }

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

    bool CanBeCarried(APrimalCharacter* ByCarrier) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalCharacter.CanBeCarried", ByCarrier); }

    bool CanBeDragged() { return NativeCall<bool>(this, "APrimalCharacter.CanBeDragged"); }

    bool CanBePainted() { return NativeCall<bool>(this, "APrimalCharacter.CanBePainted"); }

    bool CanBeTargetedBy(ITargetableInterface* Attacker) { return NativeCall<bool, ITargetableInterface*>(this, "APrimalCharacter.CanBeTargetedBy", Attacker); }

    bool CanDodgeInternal() { return NativeCall<bool>(this, "APrimalCharacter.CanDodgeInternal"); }

    bool CanDragCharacter(APrimalCharacter* Character) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalCharacter.CanDragCharacter", Character); }

    bool CanHitStagger() { return NativeCall<bool>(this, "APrimalCharacter.CanHitStagger"); }

    bool CanIgnoreImmobilizationTrap(TSubclassOf<APrimalStructure> TrapClass, bool* bForceTrigger) { return NativeCall<bool, TSubclassOf<APrimalStructure>, bool*>(this, "APrimalCharacter.CanIgnoreImmobilizationTrap", TrapClass, bForceTrigger); }

    bool CanJumpInternal_Implementation() { return NativeCall<bool>(this, "APrimalCharacter.CanJumpInternal_Implementation"); }

    bool CanMountOnMe(APrimalDinoCharacter* dinoCharacter) { return NativeCall<bool, APrimalDinoCharacter*>(this, "APrimalCharacter.CanMountOnMe", dinoCharacter); }

    bool CanMove() { return NativeCall<bool>(this, "APrimalCharacter.CanMove"); }

    bool CanSetShieldState(bool bLowerShield) { return NativeCall<bool, bool>(this, "APrimalCharacter.CanSetShieldState", bLowerShield); }

    bool CanTeleportOntoClosestValidRaft(APlayerController* ForPC, FVector* FoundLocation) { return NativeCall<bool, APlayerController*, FVector*>(this, "APrimalCharacter.CanTeleportOntoClosestValidRaft", ForPC, FoundLocation); }

    bool CanTeleportOntoRaft(APrimalRaft* OnRaft, APlayerController* ForPC) { return NativeCall<bool, APrimalRaft*, APlayerController*>(this, "APrimalCharacter.CanTeleportOntoRaft", OnRaft, ForPC); }

    void CaptureCharacterSnapshot(UPrimalItem* Item) { NativeCall<void, UPrimalItem*>(this, "APrimalCharacter.CaptureCharacterSnapshot", Item); }

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

    void ChangeAnimBlueprintIfNeeded() { NativeCall<void>(this, "APrimalCharacter.ChangeAnimBlueprintIfNeeded"); }

    bool CharacterIsCarriedAsPassenger() { return NativeCall<bool>(this, "APrimalCharacter.CharacterIsCarriedAsPassenger"); }

    void CheckBlockingAndAdjustDamage(float* Damage, FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { NativeCall<void, float*, FDamageEvent*, AController*, AActor*>(this, "APrimalCharacter.CheckBlockingAndAdjustDamage", Damage, DamageEvent, EventInstigator, DamageCauser); }

    void CheckJumpInput(float DeltaTime) { NativeCall<void, float>(this, "APrimalCharacter.CheckJumpInput", DeltaTime); }

    void CheckJumpOutOfWater() { NativeCall<void>(this, "APrimalCharacter.CheckJumpOutOfWater"); }

    void CheckRagdollPenetration() { NativeCall<void>(this, "APrimalCharacter.CheckRagdollPenetration"); }

    void ClearMountedDino(bool fromMountedDino) { NativeCall<void, bool>(this, "APrimalCharacter.ClearMountedDino", fromMountedDino); }

    void ClearRagdollPhysics() { NativeCall<void>(this, "APrimalCharacter.ClearRagdollPhysics"); }

    void ClientDidPoop_Implementation() { NativeCall<void>(this, "APrimalCharacter.ClientDidPoop_Implementation"); }

    void ClientFailedPoop_Implementation() { NativeCall<void>(this, "APrimalCharacter.ClientFailedPoop_Implementation"); }

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

    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 ClientPrepareForSeamlessTravel_Implementation() { NativeCall<void>(this, "APrimalCharacter.ClientPrepareForSeamlessTravel_Implementation"); }

    void ClientStopAnimationFPV_Implementation(UAnimMontage* AnimMontage, bool bStopOnOwner, float BlendOutTime) { NativeCall<void, UAnimMontage*, bool, float>(this, "APrimalCharacter.ClientStopAnimationFPV_Implementation", AnimMontage, bStopOnOwner, BlendOutTime); }

    void ClientStopAnimation_Implementation(UAnimMontage* AnimMontage, bool bStopOnOwner, float BlendOutTime) { NativeCall<void, UAnimMontage*, bool, float>(this, "APrimalCharacter.ClientStopAnimation_Implementation", AnimMontage, bStopOnOwner, BlendOutTime); }

    float ConsumeWeaponBreakLife(UClass* WeaponClass, float BreakWeightToConsume) { return NativeCall<float, UClass*, float>(this, "APrimalCharacter.ConsumeWeaponBreakLife", WeaponClass, BreakWeightToConsume); }

    void ControllerLeavingGame(AShooterPlayerController* theController) { NativeCall<void, AShooterPlayerController*>(this, "APrimalCharacter.ControllerLeavingGame", theController); }

    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 DeactivateBuffs(TSubclassOf<APrimalBuff> ForBuffClass, UPrimalItem* ForInstigatorItem, bool perfectClassMatch) { NativeCall<void, TSubclassOf<APrimalBuff>, UPrimalItem*, bool>(this, "APrimalCharacter.DeactivateBuffs", ForBuffClass, ForInstigatorItem, perfectClassMatch); }

    void DeathHarvestingFadeOut_Implementation() { NativeCall<void>(this, "APrimalCharacter.DeathHarvestingFadeOut_Implementation"); }

    void DestroyInventory() { NativeCall<void>(this, "APrimalCharacter.DestroyInventory"); }

    void Destroyed() { NativeCall<void>(this, "APrimalCharacter.Destroyed"); }

    void DidLand() { NativeCall<void>(this, "APrimalCharacter.DidLand"); }

    void DidTeleport_Implementation(FVector newLoc, FRotator newRot) { NativeCall<void, FVector, FRotator>(this, "APrimalCharacter.DidTeleport_Implementation", newLoc, newRot); }

    bool Die(float KillingDamage, FDamageEvent* DamageEvent, AController* Killer, AActor* DamageCauser) { return NativeCall<bool, float, FDamageEvent*, AController*, AActor*>(this, "APrimalCharacter.Die", KillingDamage, DamageEvent, Killer, DamageCauser); }

    bool DinoMountOnMe(APrimalDinoCharacter* dinoCharacter, bool bForce) { return NativeCall<bool, APrimalDinoCharacter*, bool>(this, "APrimalCharacter.DinoMountOnMe", dinoCharacter, bForce); }

    void DisableShipReducedCharacterDrawDistance(bool bIsFromSeatingStructure) { NativeCall<void, bool>(this, "APrimalCharacter.DisableShipReducedCharacterDrawDistance", bIsFromSeatingStructure); }

    void DoCharacterDetachment(bool bIncludeRiding, bool bIncludeCarrying, APrimalBuff* BuffToIgnore) { NativeCall<void, bool, bool, APrimalBuff*>(this, "APrimalCharacter.DoCharacterDetachment", bIncludeRiding, bIncludeCarrying, BuffToIgnore); }

    void DoExecuteActorConstruction(FTransform* Transform, bool bIsDefaultTransform) { NativeCall<void, FTransform*, bool>(this, "APrimalCharacter.DoExecuteActorConstruction", Transform, bIsDefaultTransform); }

    void DoFindGoodSpot(FVector RagdollLoc, bool bClearCollisionSweep) { NativeCall<void, FVector, bool>(this, "APrimalCharacter.DoFindGoodSpot", RagdollLoc, bClearCollisionSweep); }

    void DoSetRagdollPhysics() { NativeCall<void>(this, "APrimalCharacter.DoSetRagdollPhysics"); }

    void DownCallOne() { NativeCall<void>(this, "APrimalCharacter.DownCallOne"); }

    void DrawHUD(AShooterHUD* HUD) { NativeCall<void, AShooterHUD*>(this, "APrimalCharacter.DrawHUD", HUD); }

    void DrawLocalPlayerHUD(AShooterHUD* HUD) { NativeCall<void, AShooterHUD*>(this, "APrimalCharacter.DrawLocalPlayerHUD", HUD); }

    void DropAllCarriedAndPassengers() { NativeCall<void>(this, "APrimalCharacter.DropAllCarriedAndPassengers"); }

    void DualWieldingSwitchSideWeapon(UPrimalItem* aPrimalItem, bool bIsPrimaryWeapon) { NativeCall<void, UPrimalItem*, bool>(this, "APrimalCharacter.DualWieldingSwitchSideWeapon", aPrimalItem, bIsPrimaryWeapon); }

    void EmitPoop() { NativeCall<void>(this, "APrimalCharacter.EmitPoop"); }

    void EnableBPTimerNonDedicated(bool bEnable) { NativeCall<void, bool>(this, "APrimalCharacter.EnableBPTimerNonDedicated", bEnable); }

    void EnableBPTimerServer(bool bEnable) { NativeCall<void, bool>(this, "APrimalCharacter.EnableBPTimerServer", bEnable); }

    void EnableBodiesGravity() { NativeCall<void>(this, "APrimalCharacter.EnableBodiesGravity"); }

    void EnableShipReducedCharacterDrawDistance(bool bIsFromSeatingStructure) { NativeCall<void, bool>(this, "APrimalCharacter.EnableShipReducedCharacterDrawDistance", bIsFromSeatingStructure); }

    void EndDragCharacter() { NativeCall<void>(this, "APrimalCharacter.EndDragCharacter"); }

    void EndForceSkelUpdate() { NativeCall<void>(this, "APrimalCharacter.EndForceSkelUpdate"); }

    bool ExcludePostProcessBlendableMaterial(UMaterialInterface* BlendableMaterialInterface) { return NativeCall<bool, UMaterialInterface*>(this, "APrimalCharacter.ExcludePostProcessBlendableMaterial", BlendableMaterialInterface); }

    void ExecSetPawnSleeping(bool bEnable) { NativeCall<void, bool>(this, "APrimalCharacter.ExecSetPawnSleeping", bEnable); }

    void ExecSetSleeping(bool bEnable) { NativeCall<void, bool>(this, "APrimalCharacter.ExecSetSleeping", bEnable); }

    void FadeOutLoadingMusic() { NativeCall<void>(this, "APrimalCharacter.FadeOutLoadingMusic"); }

    void FellOutOfWorld(UDamageType* dmgType) { NativeCall<void, UDamageType*>(this, "APrimalCharacter.FellOutOfWorld", dmgType); }

    void FinalLoadedFromSaveGame() { NativeCall<void>(this, "APrimalCharacter.FinalLoadedFromSaveGame"); }

    APrimalRaft* FindClosestTeleportRaft(APlayerController* ForPC) { return NativeCall<APrimalRaft*, APlayerController*>(this, "APrimalCharacter.FindClosestTeleportRaft", ForPC); }

    bool FindTeleportLocation(FVector* TeleportLoc, APrimalRaft* OnRaft, FVector TargetLoc) { return NativeCall<bool, FVector*, APrimalRaft*, FVector>(this, "APrimalCharacter.FindTeleportLocation", TeleportLoc, OnRaft, TargetLoc); }

    bool ForceAddUnderwaterCharacterStatusValues() { return NativeCall<bool>(this, "APrimalCharacter.ForceAddUnderwaterCharacterStatusValues"); }

    bool ForceAllowAddBuffOfClass(TSubclassOf<APrimalBuff> BuffClass) { return NativeCall<bool, TSubclassOf<APrimalBuff>>(this, "APrimalCharacter.ForceAllowAddBuffOfClass", BuffClass); }

    void ForceClearBase(bool bAlsoSetFallingMovementMode) { NativeCall<void, bool>(this, "APrimalCharacter.ForceClearBase", bAlsoSetFallingMovementMode); }

    void ForceRefreshBones() { NativeCall<void>(this, "APrimalCharacter.ForceRefreshBones"); }

    void ForceSleepRagdoll() { NativeCall<void>(this, "APrimalCharacter.ForceSleepRagdoll"); }

    void ForceTickPoseDelta() { NativeCall<void>(this, "APrimalCharacter.ForceTickPoseDelta"); }

    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); }

    static void ForceUpdateCharacter(UWorld* World, APrimalCharacter* primalChar) { NativeCall<void, UWorld*, APrimalCharacter*>(nullptr, "APrimalCharacter.ForceUpdateCharacter", World, primalChar); }

    float GetAIDifficultyValue() { return NativeCall<float>(this, "APrimalCharacter.GetAIDifficultyValue"); }

    FVector* GetAbsoluteDynamicBasedLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APrimalCharacter.GetAbsoluteDynamicBasedLocation", result); }

    FVector* GetAdjustedMeleeLockOnPointOffset(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APrimalCharacter.GetAdjustedMeleeLockOnPointOffset", result); }

    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); }

    APrimalStructureExplosive* GetAttachedExplosive() { return NativeCall<APrimalStructureExplosive*>(this, "APrimalCharacter.GetAttachedExplosive"); }

    float GetBallistaReloadSpeedMultiplier() { return NativeCall<float>(this, "APrimalCharacter.GetBallistaReloadSpeedMultiplier"); }

    FRotator* GetBaseAimRotation(FRotator* result) { return NativeCall<FRotator*, FRotator*>(this, "APrimalCharacter.GetBaseAimRotation", result); }

    float GetBaseDragWeight() { return NativeCall<float>(this, "APrimalCharacter.GetBaseDragWeight"); }

    APrimalDinoCharacter* GetBasedOnDino() { return NativeCall<APrimalDinoCharacter*>(this, "APrimalCharacter.GetBasedOnDino"); }

    APrimalDinoCharacter* GetBasedOnDinoOrRaft() { return NativeCall<APrimalDinoCharacter*>(this, "APrimalCharacter.GetBasedOnDinoOrRaft"); }

    APrimalRaft* GetBasedOnRaft(bool bOnlyCountDirectBase, bool bOnlyCountIndirectBase) { return NativeCall<APrimalRaft*, bool, bool>(this, "APrimalCharacter.GetBasedOnRaft", bOnlyCountDirectBase, bOnlyCountIndirectBase); }

    TArray<AActor*>* GetBasedPawns(TArray<AActor*>* result) { return NativeCall<TArray<AActor*>*, TArray<AActor*>*>(this, "APrimalCharacter.GetBasedPawns", result); }

    APrimalBuff* GetBuff(TSubclassOf<APrimalBuff> BuffClass, bool bOnlyReturnSkillBuff, bool bOnlyReturnActivatedBuff, bool bUseExactMatch) { return NativeCall<APrimalBuff*, TSubclassOf<APrimalBuff>, bool, bool, bool>(this, "APrimalCharacter.GetBuff", BuffClass, bOnlyReturnSkillBuff, bOnlyReturnActivatedBuff, bUseExactMatch); }

    APrimalBuff* GetBuffForPostEffect(UMaterialInterface* anEffect) { return NativeCall<APrimalBuff*, UMaterialInterface*>(this, "APrimalCharacter.GetBuffForPostEffect", anEffect); }

    void GetBuffs(TArray<APrimalBuff*>* TheBuffs) { NativeCall<void, TArray<APrimalBuff*>*>(this, "APrimalCharacter.GetBuffs", TheBuffs); }

    FVector* GetCapsuleBottomLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APrimalCharacter.GetCapsuleBottomLocation", result); }

    FVector* GetCapsuleTopLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APrimalCharacter.GetCapsuleTopLocation", result); }

    float GetCharacterLevel() { return NativeCall<float>(this, "APrimalCharacter.GetCharacterLevel"); }

    UPrimalCharacterStatusComponent* GetCharacterStatusComponent() { return NativeCall<UPrimalCharacterStatusComponent*>(this, "APrimalCharacter.GetCharacterStatusComponent"); }

    float GetClientRotationInterpSpeed(FVector* RootLoc) { return NativeCall<float, FVector*>(this, "APrimalCharacter.GetClientRotationInterpSpeed", RootLoc); }

    float GetCorpseDecayRate() { return NativeCall<float>(this, "APrimalCharacter.GetCorpseDecayRate"); }

    float GetCorpseLifespan() { return NativeCall<float>(this, "APrimalCharacter.GetCorpseLifespan"); }

    float GetCurrentStatusValue(EPrimalCharacterStatusValue::Type StatusValueType) { return NativeCall<float, EPrimalCharacterStatusValue::Type>(this, "APrimalCharacter.GetCurrentStatusValue", StatusValueType); }

    TArray<UAnimMontage*>* GetCurrentlyPlayingAnimations(TArray<UAnimMontage*>* result, bool bReturnIfAnyFound, TArray<FName> SlotsToInclude, TArray<FName> SlotsToExclude, TArray<FName> TagsToInclude, TArray<FName> TagsToExclude, TArray<UAnimMontage*> AnimationsToExclude) { return NativeCall<TArray<UAnimMontage*>*, TArray<UAnimMontage*>*, bool, TArray<FName>, TArray<FName>, TArray<FName>, TArray<FName>, TArray<UAnimMontage*>>(this, "APrimalCharacter.GetCurrentlyPlayingAnimations", result, bReturnIfAnyFound, SlotsToInclude, SlotsToExclude, TagsToInclude, TagsToExclude, AnimationsToExclude); }

    float GetDamageTorpidityIncreaseMultiplierScale() { return NativeCall<float>(this, "APrimalCharacter.GetDamageTorpidityIncreaseMultiplierScale"); }

    float GetDefaultMovementSpeed() { return NativeCall<float>(this, "APrimalCharacter.GetDefaultMovementSpeed"); }

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

    int GetDirectionalIndexByVector(FVector* TestVec, bool isDodgeTest, float Tolerance) { return NativeCall<int, FVector*, bool, float>(this, "APrimalCharacter.GetDirectionalIndexByVector", TestVec, isDodgeTest, Tolerance); }

    FVector* GetDirectionalVectorByIndex(FVector* result, const int DirIndex) { return NativeCall<FVector*, FVector*, const int>(this, "APrimalCharacter.GetDirectionalVectorByIndex", result, DirIndex); }

    float GetDodgeDurationMultiplier() { return NativeCall<float>(this, "APrimalCharacter.GetDodgeDurationMultiplier"); }

    float GetDragWeight(APrimalCharacter* ForDragger) { return NativeCall<float, APrimalCharacter*>(this, "APrimalCharacter.GetDragWeight", ForDragger); }

    float GetFallAcceleration() { return NativeCall<float>(this, "APrimalCharacter.GetFallAcceleration"); }

    EPhysicalSurface GetFootPhysicalSurfaceType(bool bForce) { return NativeCall<EPhysicalSurface, bool>(this, "APrimalCharacter.GetFootPhysicalSurfaceType", bForce); }

    float GetGravityZScale() { return NativeCall<float>(this, "APrimalCharacter.GetGravityZScale"); }

    bool GetGroundLocation(FVector* theGroundLoc, FVector* OffsetUp, FVector* OffsetDown, AActor* IgnoredActor) { return NativeCall<bool, FVector*, FVector*, FVector*, AActor*>(this, "APrimalCharacter.GetGroundLocation", theGroundLoc, OffsetUp, OffsetDown, IgnoredActor); }

    float GetHealth() { return NativeCall<float>(this, "APrimalCharacter.GetHealth"); }

    float GetHealthPercentage() { return NativeCall<float>(this, "APrimalCharacter.GetHealthPercentage"); }

    float GetImmersionDepth(bool bUseLineTrace) { return NativeCall<float, bool>(this, "APrimalCharacter.GetImmersionDepth", bUseLineTrace); }

    float GetIndirectTorpidityIncreaseMultiplierScale() { return NativeCall<float>(this, "APrimalCharacter.GetIndirectTorpidityIncreaseMultiplierScale"); }

    FVector* GetInterpolatedLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APrimalCharacter.GetInterpolatedLocation", result); }

    FRotator* GetInterpolatedRotation(FRotator* result) { return NativeCall<FRotator*, FRotator*>(this, "APrimalCharacter.GetInterpolatedRotation", result); }

    float GetJumpZModifier() { return NativeCall<float>(this, "APrimalCharacter.GetJumpZModifier"); }

    float GetKillXP() { return NativeCall<float>(this, "APrimalCharacter.GetKillXP"); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "APrimalCharacter.GetLifetimeReplicatedProps", OutLifetimeProps); }

    float GetLowHealthPercentage() { return NativeCall<float>(this, "APrimalCharacter.GetLowHealthPercentage"); }

    float GetMaxCursorHUDDistance(AShooterPlayerController* PC) { return NativeCall<float, AShooterPlayerController*>(this, "APrimalCharacter.GetMaxCursorHUDDistance", PC); }

    float GetMaxHealth() { return NativeCall<float>(this, "APrimalCharacter.GetMaxHealth"); }

    float GetMaxSpeedModifier() { return NativeCall<float>(this, "APrimalCharacter.GetMaxSpeedModifier"); }

    float GetMaxStatusValue(EPrimalCharacterStatusValue::Type StatusValueType) { return NativeCall<float, EPrimalCharacterStatusValue::Type>(this, "APrimalCharacter.GetMaxStatusValue", StatusValueType); }

    int GetNearestBoneIndexForDrag(APrimalCharacter* Character, FVector HitLocation) { return NativeCall<int, APrimalCharacter*, FVector>(this, "APrimalCharacter.GetNearestBoneIndexForDrag", Character, HitLocation); }

    UTexture2D* GetOverrideDefaultCharacterParamTexture(FName theParamName, UTexture2D* CurrentTexture) { return NativeCall<UTexture2D*, FName, UTexture2D*>(this, "APrimalCharacter.GetOverrideDefaultCharacterParamTexture", theParamName, CurrentTexture); }

    UPaintingTexture* GetPaintingTexture(bool bForTattoo, UPrimalPlayerData* TattooPlayerData) { return NativeCall<UPaintingTexture*, bool, UPrimalPlayerData*>(this, "APrimalCharacter.GetPaintingTexture", bForTattoo, TattooPlayerData); }

    USceneComponent* GetParticleBaseComponent() { return NativeCall<USceneComponent*>(this, "APrimalCharacter.GetParticleBaseComponent"); }

    float GetPercentStatusValue(EPrimalCharacterStatusValue::Type StatusValueType) { return NativeCall<float, EPrimalCharacterStatusValue::Type>(this, "APrimalCharacter.GetPercentStatusValue", StatusValueType); }

    UPrimitiveComponent* GetPrimaryHitComponent() { return NativeCall<UPrimitiveComponent*>(this, "APrimalCharacter.GetPrimaryHitComponent"); }

    float GetProjectileDamageMultiplier() { return NativeCall<float>(this, "APrimalCharacter.GetProjectileDamageMultiplier"); }

    ENetRole GetRole() { return NativeCall<ENetRole>(this, "APrimalCharacter.GetRole"); }

    FVector* GetRootBodyBoneLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APrimalCharacter.GetRootBodyBoneLocation", result); }

    float BPGetAddForwardVelocityOnJump_Implementation() { return NativeCall<float>(this, "APrimalCharacter.BPGetAddForwardVelocityOnJump_Implementation"); }

    float GetRunningSpeedModifier(bool bIsForDefaultSpeed) { return NativeCall<float, bool>(this, "APrimalCharacter.GetRunningSpeedModifier", bIsForDefaultSpeed); }

    UAnimSequence* GetSeatingAnimation() { return NativeCall<UAnimSequence*>(this, "APrimalCharacter.GetSeatingAnimation"); }

    UAnimSequence* GetShieldHeldAnimation() { return NativeCall<UAnimSequence*>(this, "APrimalCharacter.GetShieldHeldAnimation"); }

    UPrimalItem* GetShieldItem() { return NativeCall<UPrimalItem*>(this, "APrimalCharacter.GetShieldItem"); }

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

    static UActorComponent* GetSnapshotComponent(AActor* From, FName Tag) { return NativeCall<UActorComponent*, AActor*, FName>(nullptr, "APrimalCharacter.GetSnapshotComponent", From, Tag); }

    float GetSpoilingTimeMultiplier(UPrimalItem* anItem) { return NativeCall<float, UPrimalItem*>(this, "APrimalCharacter.GetSpoilingTimeMultiplier", anItem); }

    FVector* GetTargetPathfindingLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APrimalCharacter.GetTargetPathfindingLocation", result); }

    FVector* GetTargetingLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APrimalCharacter.GetTargetingLocation", result); }

    FVector* GetVelocity(FVector* result, bool bIsForRagdoll) { return NativeCall<FVector*, FVector*, bool>(this, "APrimalCharacter.GetVelocity", result, bIsForRagdoll); }

    FRotator* GetViewRotation(FRotator* result) { return NativeCall<FRotator*, FRotator*>(this, "APrimalCharacter.GetViewRotation", result); }

    float GetWaterSubmergedDepthThreshold() { return NativeCall<float>(this, "APrimalCharacter.GetWaterSubmergedDepthThreshold"); }

    FName* GetWeaponAttachPoint(FName* result, bool bSecondaryAttachPoint) { return NativeCall<FName*, FName*, bool>(this, "APrimalCharacter.GetWeaponAttachPoint", result, bSecondaryAttachPoint); }

    float GetWeaponBaseSpeedModifier() { return NativeCall<float>(this, "APrimalCharacter.GetWeaponBaseSpeedModifier"); }

    float GetWeaponRunSpeed() { return NativeCall<float>(this, "APrimalCharacter.GetWeaponRunSpeed"); }

    float GetWeaponSpeedMultiplierByDirection(FVector* CharacterDir, FVector* MovementDir) { return NativeCall<float, FVector*, FVector*>(this, "APrimalCharacter.GetWeaponSpeedMultiplierByDirection", CharacterDir, MovementDir); }

    UPrimalItem_Shield* GetYarkShieldItem() { return NativeCall<UPrimalItem_Shield*>(this, "APrimalCharacter.GetYarkShieldItem"); }

    void GiveDefaultWeapon(bool bForceGiveDefaultWeapon) { NativeCall<void, bool>(this, "APrimalCharacter.GiveDefaultWeapon", bForceGiveDefaultWeapon); }

    void GiveDefaultWeaponTimer() { NativeCall<void>(this, "APrimalCharacter.GiveDefaultWeaponTimer"); }

    void GivePrimalItemWeapon(UPrimalItem* aPrimalItem) { NativeCall<void, UPrimalItem*>(this, "APrimalCharacter.GivePrimalItemWeapon", aPrimalItem); }

    bool HasBuff(TSubclassOf<APrimalBuff> BuffClass, bool useExactMatch) { return NativeCall<bool, TSubclassOf<APrimalBuff>, bool>(this, "APrimalCharacter.HasBuff", BuffClass, useExactMatch); }

    bool HasShieldAttackForInput(EWeaponAttackInput::Type AttackInput) { return NativeCall<bool, EWeaponAttackInput::Type>(this, "APrimalCharacter.HasShieldAttackForInput", AttackInput); }

    void HurtMe(int HowMuch) { NativeCall<void, int>(this, "APrimalCharacter.HurtMe", HowMuch); }

    void Immobilize(bool bImmobilize, AActor* UsingActor, bool bImmobilizeFalling) { NativeCall<void, bool, AActor*, bool>(this, "APrimalCharacter.Immobilize", bImmobilize, UsingActor, bImmobilizeFalling); }

    void InitializedAnimScriptInstance() { NativeCall<void>(this, "APrimalCharacter.InitializedAnimScriptInstance"); }

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

    bool IsAlive() { return NativeCall<bool>(this, "APrimalCharacter.IsAlive"); }

    bool IsAlliedWithOtherTeam(int OtherTeamID) { return NativeCall<bool, int>(this, "APrimalCharacter.IsAlliedWithOtherTeam", OtherTeamID); }

    bool IsAttachedToSomething() { return NativeCall<bool>(this, "APrimalCharacter.IsAttachedToSomething"); }

    bool IsBasedOnRaft(APrimalRaft* SpecificRaft) { return NativeCall<bool, APrimalRaft*>(this, "APrimalCharacter.IsBasedOnRaft", SpecificRaft); }

    bool IsBlockedByShield(FHitResult* HitInfo, FVector* ShotDirection, bool bBlockAllPointDamage, bool bDamageIsFromYarkWeapon) { return NativeCall<bool, FHitResult*, FVector*, bool, bool>(this, "APrimalCharacter.IsBlockedByShield", HitInfo, ShotDirection, bBlockAllPointDamage, bDamageIsFromYarkWeapon); }

    bool IsBlockingWithShield(bool bCheckActiveBlocking, float TimeFromTransitionEndToConsiderFinished) { return NativeCall<bool, bool, float>(this, "APrimalCharacter.IsBlockingWithShield", bCheckActiveBlocking, TimeFromTransitionEndToConsiderFinished); }

    bool IsBlockingWithWeapon() { return NativeCall<bool>(this, "APrimalCharacter.IsBlockingWithWeapon"); }

    bool IsCarryingSomething(bool bNotForRunning) { return NativeCall<bool, bool>(this, "APrimalCharacter.IsCarryingSomething", bNotForRunning); }

    bool IsCharacterHardAttached(bool bIgnoreRiding, bool bIgnoreCarried) { return NativeCall<bool, bool, bool>(this, "APrimalCharacter.IsCharacterHardAttached", bIgnoreRiding, bIgnoreCarried); }

    bool IsConscious() { return NativeCall<bool>(this, "APrimalCharacter.IsConscious"); }

    bool IsControllingBallistaTurret() { return NativeCall<bool>(this, "APrimalCharacter.IsControllingBallistaTurret"); }

    bool IsDead() { return NativeCall<bool>(this, "APrimalCharacter.IsDead"); }

    bool IsDodgeDirectionAllowed(int DodgeDirection) { return NativeCall<bool, int>(this, "APrimalCharacter.IsDodgeDirectionAllowed", DodgeDirection); }

    bool IsDraggingCharacter() { return NativeCall<bool>(this, "APrimalCharacter.IsDraggingCharacter"); }

    bool IsFiring() { return NativeCall<bool>(this, "APrimalCharacter.IsFiring"); }

    bool IsIkCurveReversed() { return NativeCall<bool>(this, "APrimalCharacter.IsIkCurveReversed"); }

    bool IsInOceanWater() { return NativeCall<bool>(this, "APrimalCharacter.IsInOceanWater"); }

    bool IsInStatusState(EPrimalCharacterStatusState::Type StatusStateType) { return NativeCall<bool, EPrimalCharacterStatusState::Type>(this, "APrimalCharacter.IsInStatusState", StatusStateType); }

    bool IsInVacuumSealedSpace() { return NativeCall<bool>(this, "APrimalCharacter.IsInVacuumSealedSpace"); }

    bool IsInputAllowed() { return NativeCall<bool>(this, "APrimalCharacter.IsInputAllowed"); }

    bool IsInvincible(int AttackerTeam) { return NativeCall<bool, int>(this, "APrimalCharacter.IsInvincible", AttackerTeam); }

    bool IsMeshGameplayRelevant() { return NativeCall<bool>(this, "APrimalCharacter.IsMeshGameplayRelevant"); }

    bool IsMontagePlaying(UAnimMontage* AnimMontage, float TimeFromEndToConsiderFinished) { return NativeCall<bool, UAnimMontage*, float>(this, "APrimalCharacter.IsMontagePlaying", AnimMontage, TimeFromEndToConsiderFinished); }

    bool IsMoving() { return NativeCall<bool>(this, "APrimalCharacter.IsMoving"); }

    bool IsOfTribe(int ID) { return NativeCall<bool, int>(this, "APrimalCharacter.IsOfTribe", ID); }

    bool IsOnSeatingStructure() { return NativeCall<bool>(this, "APrimalCharacter.IsOnSeatingStructure"); }

    UAnimMontage* IsPlayingAnyFullBodyAnimations(UAnimMontage* IgnoreFullBodyMontage) { return NativeCall<UAnimMontage*, UAnimMontage*>(this, "APrimalCharacter.IsPlayingAnyFullBodyAnimations", IgnoreFullBodyMontage); }

    bool IsPrimalCharFriendly(APrimalCharacter* primalChar) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalCharacter.IsPrimalCharFriendly", primalChar); }

    bool IsProneOrSitting(bool bIgnoreLockedToSeat) { return NativeCall<bool, bool>(this, "APrimalCharacter.IsProneOrSitting", bIgnoreLockedToSeat); }

    bool IsRagdolled() { return NativeCall<bool>(this, "APrimalCharacter.IsRagdolled"); }

    bool IsRunning(bool bIncludeFalling, bool bIncludeRunTurning) { return NativeCall<bool, bool, bool>(this, "APrimalCharacter.IsRunning", bIncludeFalling, bIncludeRunTurning); }

    bool IsShieldTransitioning(float TimeFromEndToConsiderFinished) { return NativeCall<bool, float>(this, "APrimalCharacter.IsShieldTransitioning", TimeFromEndToConsiderFinished); }

    bool IsShieldTransitioningIn(float TimeFromEndToConsiderFinished) { return NativeCall<bool, float>(this, "APrimalCharacter.IsShieldTransitioningIn", TimeFromEndToConsiderFinished); }

    bool IsShieldTransitioningOut(float TimeFromEndToConsiderFinished) { return NativeCall<bool, float>(this, "APrimalCharacter.IsShieldTransitioningOut", TimeFromEndToConsiderFinished); }

    bool IsSimulated() { return NativeCall<bool>(this, "APrimalCharacter.IsSimulated"); }

    bool IsSitting(bool bIgnoreLockedToSeat) { return NativeCall<bool, bool>(this, "APrimalCharacter.IsSitting", bIgnoreLockedToSeat); }

    bool IsStaggering() { return NativeCall<bool>(this, "APrimalCharacter.IsStaggering"); }

    bool IsSubmerged(bool bDontCheckSwimming, bool bUseFullThreshold, bool bForceCheck, bool bFromVolumeChange) { return NativeCall<bool, bool, bool, bool, bool>(this, "APrimalCharacter.IsSubmerged", bDontCheckSwimming, bUseFullThreshold, bForceCheck, bFromVolumeChange); }

    bool IsSwitchingWeapons() { return NativeCall<bool>(this, "APrimalCharacter.IsSwitchingWeapons"); }

    bool IsTargetableDead() { return NativeCall<bool>(this, "APrimalCharacter.IsTargetableDead"); }

    bool IsTargeting() { return NativeCall<bool>(this, "APrimalCharacter.IsTargeting"); }

    bool IsUsingHandIK() { return NativeCall<bool>(this, "APrimalCharacter.IsUsingHandIK"); }

    bool IsUsingShield() { return NativeCall<bool>(this, "APrimalCharacter.IsUsingShield"); }

    bool IsUsingYarkShield() { return NativeCall<bool>(this, "APrimalCharacter.IsUsingYarkShield"); }

    bool IsValidCharacterToDoClaiming(int VictimTeam) { return NativeCall<bool, int>(this, "APrimalCharacter.IsValidCharacterToDoClaiming", VictimTeam); }

    bool IsValidCharacterToPreventClaiming(int AttackerTeam) { return NativeCall<bool, int>(this, "APrimalCharacter.IsValidCharacterToPreventClaiming", AttackerTeam); }

    bool IsValidForCombatMusic() { return NativeCall<bool>(this, "APrimalCharacter.IsValidForCombatMusic"); }

    bool IsValidForStatusRecovery() { return NativeCall<bool>(this, "APrimalCharacter.IsValidForStatusRecovery"); }

    bool IsValidForStatusUpdate() { return NativeCall<bool>(this, "APrimalCharacter.IsValidForStatusUpdate"); }

    bool IsValidLockOnTarget_Implementation(APawn* AttackerPawn) { return NativeCall<bool, APawn*>(this, "APrimalCharacter.IsValidLockOnTarget_Implementation", AttackerPawn); }

    bool IsWatered() { return NativeCall<bool>(this, "APrimalCharacter.IsWatered"); }

    bool IsWeaponWielder() { return NativeCall<bool>(this, "APrimalCharacter.IsWeaponWielder"); }

    void LocalPossessedBy(APlayerController* ByController) { NativeCall<void, APlayerController*>(this, "APrimalCharacter.LocalPossessedBy", ByController); }

    void LocalUnpossessed_Implementation() { NativeCall<void>(this, "APrimalCharacter.LocalUnpossessed_Implementation"); }

    void LookInput(float Val) { NativeCall<void, float>(this, "APrimalCharacter.LookInput", Val); }

    void LookUpAtRate(float Val) { NativeCall<void, float>(this, "APrimalCharacter.LookUpAtRate", Val); }

    bool LowerShield() { return NativeCall<bool>(this, "APrimalCharacter.LowerShield"); }

    void MarkForSeamlessTravel(unsigned int DestinationServerId, ESeamlessVolumeSide::Side DestinationServerVolumeSide) { NativeCall<void, unsigned int, ESeamlessVolumeSide::Side>(this, "APrimalCharacter.MarkForSeamlessTravel", DestinationServerId, DestinationServerVolumeSide); }

    bool ModifyInputAcceleration(FVector* InputAcceleration) { return NativeCall<bool, FVector*>(this, "APrimalCharacter.ModifyInputAcceleration", InputAcceleration); }

    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 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); }

    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 NetDidLand_Implementation() { NativeCall<void>(this, "APrimalCharacter.NetDidLand_Implementation"); }

    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); }

    void NetOnJumped_Implementation() { NativeCall<void>(this, "APrimalCharacter.NetOnJumped_Implementation"); }

    void NetPlaySoundOnCharacter_Implementation(USoundBase* SoundToPlay, bool bPlayOnOwner) { NativeCall<void, USoundBase*, bool>(this, "APrimalCharacter.NetPlaySoundOnCharacter_Implementation", SoundToPlay, bPlayOnOwner); }

    void NetReleaseSeatingStructure_Implementation() { NativeCall<void>(this, "APrimalCharacter.NetReleaseSeatingStructure_Implementation"); }

    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); }

    void NetStopAllAnimMontage_Implementation() { NativeCall<void>(this, "APrimalCharacter.NetStopAllAnimMontage_Implementation"); }

    void NetUpdateTribeName_Implementation(FString* NewTribeName) { NativeCall<void, FString*>(this, "APrimalCharacter.NetUpdateTribeName_Implementation", NewTribeName); }

    void Net_OnIsStaggering_Implementation(bool bNewStaggering, float PlayStaggerAnimAfterDelay, bool bPlayStaggerAnim) { NativeCall<void, bool, float, bool>(this, "APrimalCharacter.Net_OnIsStaggering_Implementation", bNewStaggering, PlayStaggerAnimAfterDelay, bPlayStaggerAnim); }

    void NotifyBumpedByPawn(APrimalCharacter* ByPawn) { NativeCall<void, APrimalCharacter*>(this, "APrimalCharacter.NotifyBumpedByPawn", ByPawn); }

    void NotifyBumpedPawn(APawn* BumpedPawn) { NativeCall<void, APawn*>(this, "APrimalCharacter.NotifyBumpedPawn", BumpedPawn); }

    void NotifyItemAdded(UPrimalItem* anItem, bool bEquipItem) { NativeCall<void, UPrimalItem*, bool>(this, "APrimalCharacter.NotifyItemAdded", anItem, bEquipItem); }

    void NotifyItemQuantityUpdated(UPrimalItem* anItem, int amount) { NativeCall<void, UPrimalItem*, int>(this, "APrimalCharacter.NotifyItemQuantityUpdated", anItem, amount); }

    void NotifyItemRemoved(UPrimalItem* anItem) { NativeCall<void, UPrimalItem*>(this, "APrimalCharacter.NotifyItemRemoved", anItem); }

    void OnAttachedToCharacter() { NativeCall<void>(this, "APrimalCharacter.OnAttachedToCharacter"); }

    void OnAttachedToSeatingStructure() { NativeCall<void>(this, "APrimalCharacter.OnAttachedToSeatingStructure"); }

    void OnBeginDrag_Implementation(APrimalCharacter* Dragged, int BoneIndex, bool bWithGrapHook) { NativeCall<void, APrimalCharacter*, int, bool>(this, "APrimalCharacter.OnBeginDrag_Implementation", Dragged, BoneIndex, bWithGrapHook); }

    void OnBeginDragged(APrimalCharacter* Dragger) { NativeCall<void, APrimalCharacter*>(this, "APrimalCharacter.OnBeginDragged", Dragger); }

    void OnClientPairedNetGUID() { NativeCall<void>(this, "APrimalCharacter.OnClientPairedNetGUID"); }

    void OnClientReceivedTransformAfterPairingNetGUID(FVector* Loc, FRotator* Rot) { NativeCall<void, FVector*, FRotator*>(this, "APrimalCharacter.OnClientReceivedTransformAfterPairingNetGUID", Loc, Rot); }

    void OnDeserializedByGame(EOnDesrializationType::Type DeserializationType) { NativeCall<void, EOnDesrializationType::Type>(this, "APrimalCharacter.OnDeserializedByGame", DeserializationType); }

    void OnDetachedFromCharacter(APrimalCharacter* aCharacter, int OverrideDirection) { NativeCall<void, APrimalCharacter*, int>(this, "APrimalCharacter.OnDetachedFromCharacter", aCharacter, OverrideDirection); }

    void OnDetachedFromSeatingStructure(APrimalStructureSeating* InSeatingStructure) { NativeCall<void, APrimalStructureSeating*>(this, "APrimalCharacter.OnDetachedFromSeatingStructure", InSeatingStructure); }

    void OnEndDrag_Implementation() { NativeCall<void>(this, "APrimalCharacter.OnEndDrag_Implementation"); }

    void OnEndDragged(APrimalCharacter* Dragger) { NativeCall<void, APrimalCharacter*>(this, "APrimalCharacter.OnEndDragged", Dragger); }

    void OnIgnoredMoveToOrder(APlayerController* FromPC) { NativeCall<void, APlayerController*>(this, "APrimalCharacter.OnIgnoredMoveToOrder", FromPC); }

    void OnJumped_Implementation() { NativeCall<void>(this, "APrimalCharacter.OnJumped_Implementation"); }

    void OnLanded(FHitResult* Hit) { NativeCall<void, FHitResult*>(this, "APrimalCharacter.OnLanded", Hit); }

    void OnMovementModeChanged(EMovementMode PrevMovementMode, char PreviousCustomMode) { NativeCall<void, EMovementMode, char>(this, "APrimalCharacter.OnMovementModeChanged", PrevMovementMode, PreviousCustomMode); }

    void OnPrimalCharacterSleeped() { NativeCall<void>(this, "APrimalCharacter.OnPrimalCharacterSleeped"); }

    void OnPrimalCharacterUnsleeped() { NativeCall<void>(this, "APrimalCharacter.OnPrimalCharacterUnsleeped"); }

    void OnRep_CurrentWeapon(AShooterWeapon* LastWeapon) { NativeCall<void, AShooterWeapon*>(this, "APrimalCharacter.OnRep_CurrentWeapon", LastWeapon); }

    void OnRep_IsDead() { NativeCall<void>(this, "APrimalCharacter.OnRep_IsDead"); }

    void OnRep_IsSleeping() { NativeCall<void>(this, "APrimalCharacter.OnRep_IsSleeping"); }

    void OnRep_MountedDino() { NativeCall<void>(this, "APrimalCharacter.OnRep_MountedDino"); }

    void OnRep_PaintingComponent() { NativeCall<void>(this, "APrimalCharacter.OnRep_PaintingComponent"); }

    void OnRep_RagdollPositions() { NativeCall<void>(this, "APrimalCharacter.OnRep_RagdollPositions"); }

    void OnRunToggle() { NativeCall<void>(this, "APrimalCharacter.OnRunToggle"); }

    void OnShieldDefenseBroken(float StaggerTime) { NativeCall<void, float>(this, "APrimalCharacter.OnShieldDefenseBroken", StaggerTime); }

    void OnStartAltFire() { NativeCall<void>(this, "APrimalCharacter.OnStartAltFire"); }

    void OnStartBlockingAttack() { NativeCall<void>(this, "APrimalCharacter.OnStartBlockingAttack"); }

    void OnStartBreakingAttack() { NativeCall<void>(this, "APrimalCharacter.OnStartBreakingAttack"); }

    void OnStartFire(bool bFromGamepadRight, int weaponAttackIndex, bool bDoLeftSide, bool bOverrideCurrentAttack) { NativeCall<void, bool, int, bool, bool>(this, "APrimalCharacter.OnStartFire", bFromGamepadRight, weaponAttackIndex, bDoLeftSide, bOverrideCurrentAttack); }

    void OnStartFireQuinary() { NativeCall<void>(this, "APrimalCharacter.OnStartFireQuinary"); }

    void OnStartJump() { NativeCall<void>(this, "APrimalCharacter.OnStartJump"); }

    void OnStartRunning() { NativeCall<void>(this, "APrimalCharacter.OnStartRunning"); }

    void OnStopAltFire() { NativeCall<void>(this, "APrimalCharacter.OnStopAltFire"); }

    void OnStopBlockingAttack() { NativeCall<void>(this, "APrimalCharacter.OnStopBlockingAttack"); }

    void OnStopBreakingAttack() { NativeCall<void>(this, "APrimalCharacter.OnStopBreakingAttack"); }

    void OnStopFire(bool bFromGamepadRight, int weaponAttackIndex) { NativeCall<void, bool, int>(this, "APrimalCharacter.OnStopFire", bFromGamepadRight, weaponAttackIndex); }

    void OnStopFireQuinary() { NativeCall<void>(this, "APrimalCharacter.OnStopFireQuinary"); }

    void OnStopJump() { NativeCall<void>(this, "APrimalCharacter.OnStopJump"); }

    void OnStopRunning() { NativeCall<void>(this, "APrimalCharacter.OnStopRunning"); }

    void OnTeleportOntoRaft(APrimalRaft* OntoRaft) { NativeCall<void, APrimalRaft*>(this, "APrimalCharacter.OnTeleportOntoRaft", OntoRaft); }

    void OrbitCamOff() { NativeCall<void>(this, "APrimalCharacter.OrbitCamOff"); }

    void OrbitCamOn() { NativeCall<void>(this, "APrimalCharacter.OrbitCamOn"); }

    void OrbitCamToggle() { NativeCall<void>(this, "APrimalCharacter.OrbitCamToggle"); }

    FVector* OverrideNewFallVelocity(FVector* result, FVector* InitialVelocity, FVector* Gravity, float DeltaTime) { return NativeCall<FVector*, FVector*, FVector*, FVector*, float>(this, "APrimalCharacter.OverrideNewFallVelocity", result, InitialVelocity, Gravity, DeltaTime); }

    FVector* OverrideSwimmingVelocity(FVector* result, FVector* InitialVelocity, FVector* Gravity, const float* FluidFriction, const float* NetBuoyancy, float DeltaTime) { return NativeCall<FVector*, FVector*, FVector*, FVector*, const float*, const float*, float>(this, "APrimalCharacter.OverrideSwimmingVelocity", result, InitialVelocity, Gravity, FluidFriction, NetBuoyancy, DeltaTime); }

    FVector* OverrideWalkingVelocity(FVector* result, FVector* InitialVelocity, const float* Friction, float DeltaTime) { return NativeCall<FVector*, FVector*, FVector*, const float*, float>(this, "APrimalCharacter.OverrideWalkingVelocity", result, InitialVelocity, Friction, DeltaTime); }

    float PlayAnimEx(UAnimMontage* AnimMontage, float InPlayRate, FName StartSectionName, bool bReplicate, bool bReplicateToOwner, bool bForceTickPoseAndServerUpdateMesh, bool bForceTickPoseOnServer) { return NativeCall<float, UAnimMontage*, float, FName, bool, bool, bool, bool>(this, "APrimalCharacter.PlayAnimEx", AnimMontage, InPlayRate, StartSectionName, bReplicate, bReplicateToOwner, bForceTickPoseAndServerUpdateMesh, bForceTickPoseOnServer); }

    float PlayAnimMontage(UAnimMontage* AnimMontage, float InPlayRate, FName StartSectionName, bool bForceTickPoseAndServerUpdateMesh, bool bForceTickPoseOnServer) { return NativeCall<float, UAnimMontage*, float, FName, bool, bool>(this, "APrimalCharacter.PlayAnimMontage", AnimMontage, InPlayRate, StartSectionName, bForceTickPoseAndServerUpdateMesh, bForceTickPoseOnServer); }

    void PlayDying(float KillingDamage, FDamageEvent* DamageEvent, APawn* InstigatingPawn, AActor* DamageCauser) { NativeCall<void, float, FDamageEvent*, APawn*, AActor*>(this, "APrimalCharacter.PlayDying", KillingDamage, DamageEvent, InstigatingPawn, DamageCauser); }

    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 PlayFootstep() { NativeCall<void>(this, "APrimalCharacter.PlayFootstep"); }

    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 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); }

    void PlayJumpAnim() { NativeCall<void>(this, "APrimalCharacter.PlayJumpAnim"); }

    void PlayLandedAnim() { NativeCall<void>(this, "APrimalCharacter.PlayLandedAnim"); }

    void PlayShieldHitResponse(bool bUseHitParticles) { NativeCall<void, bool>(this, "APrimalCharacter.PlayShieldHitResponse", bUseHitParticles); }

    void PlayStaggerAnim() { NativeCall<void>(this, "APrimalCharacter.PlayStaggerAnim"); }

    FString* PlayerCommand_Implementation(FString* result, FString* TheCommand) { return NativeCall<FString*, FString*, FString*>(this, "APrimalCharacter.PlayerCommand_Implementation", result, TheCommand); }

    void Poop(bool bForcePoop) { NativeCall<void, bool>(this, "APrimalCharacter.Poop", bForcePoop); }

    void PossessedBy(AController* NewController) { NativeCall<void, AController*>(this, "APrimalCharacter.PossessedBy", NewController); }

    void PostInitializeComponents() { NativeCall<void>(this, "APrimalCharacter.PostInitializeComponents"); }

    void PostNetReceiveVelocity(FVector* NewVelocity) { NativeCall<void, FVector*>(this, "APrimalCharacter.PostNetReceiveVelocity", NewVelocity); }

    void PreInitializeComponents() { NativeCall<void>(this, "APrimalCharacter.PreInitializeComponents"); }

    void PrepareForSaving() { NativeCall<void>(this, "APrimalCharacter.PrepareForSaving"); }

    bool PreventInputDoesOffset() { return NativeCall<bool>(this, "APrimalCharacter.PreventInputDoesOffset"); }

    bool PreventInputType(EPrimalCharacterInputType::Type inputType) { return NativeCall<bool, EPrimalCharacterInputType::Type>(this, "APrimalCharacter.PreventInputType", inputType); }

    bool PreventsTargeting_Implementation(AActor* ByActor) { return NativeCall<bool, AActor*>(this, "APrimalCharacter.PreventsTargeting_Implementation", ByActor); }

    bool ProcessInputAndStartFire(bool bFromGamepadRight, EWeaponAttackInput::Type AttackInput) { return NativeCall<bool, bool, EWeaponAttackInput::Type>(this, "APrimalCharacter.ProcessInputAndStartFire", bFromGamepadRight, AttackInput); }

    bool ProcessInputAndStopFire(bool bFromGamepadRight, EWeaponAttackInput::Type AttackInput) { return NativeCall<bool, bool, EWeaponAttackInput::Type>(this, "APrimalCharacter.ProcessInputAndStopFire", bFromGamepadRight, AttackInput); }

    void ProcessStaggerForDefender(AActor* DamageCauser, int AttackerAttackIndex, int DefenderAttackIndex, bool bWasAttackBlocked) { NativeCall<void, AActor*, int, int, bool>(this, "APrimalCharacter.ProcessStaggerForDefender", DamageCauser, AttackerAttackIndex, DefenderAttackIndex, bWasAttackBlocked); }

    void Prone(bool bClientSimulation) { NativeCall<void, bool>(this, "APrimalCharacter.Prone", bClientSimulation); }

    bool RaiseShield(EWeaponAttackInput::Type AttackInput) { return NativeCall<bool, EWeaponAttackInput::Type>(this, "APrimalCharacter.RaiseShield", AttackInput); }

    void RefreshBiomeZoneVolumes() { NativeCall<void>(this, "APrimalCharacter.RefreshBiomeZoneVolumes"); }

    void RefreshEquippedItemStatGroupModifiers() { NativeCall<void>(this, "APrimalCharacter.RefreshEquippedItemStatGroupModifiers"); }

    void RefreshMyIslandInfo() { NativeCall<void>(this, "APrimalCharacter.RefreshMyIslandInfo"); }

    void ReleaseSeatingStructure(APrimalStructureSeating* InSeatingStructure) { NativeCall<void, APrimalStructureSeating*>(this, "APrimalCharacter.ReleaseSeatingStructure", InSeatingStructure); }

    void ReleasedRunToggle() { NativeCall<void>(this, "APrimalCharacter.ReleasedRunToggle"); }

    void RemoveAllJumpDeactivatedBuffs(APrimalBuff* IgnoredBuff) { NativeCall<void, APrimalBuff*>(this, "APrimalCharacter.RemoveAllJumpDeactivatedBuffs", IgnoredBuff); }

    void RemoveCharacterSnapshot(UPrimalItem* Item, AActor* From) { NativeCall<void, UPrimalItem*, AActor*>(this, "APrimalCharacter.RemoveCharacterSnapshot", Item, From); }

    void ReplicateRagdoll() { NativeCall<void>(this, "APrimalCharacter.ReplicateRagdoll"); }

    void ResetCollisionSweepLocation(FVector* newLocation) { NativeCall<void, FVector*>(this, "APrimalCharacter.ResetCollisionSweepLocation", newLocation); }

    void ServerDinoOrder_Implementation(APrimalDinoCharacter* aDino, EDinoTamedOrder::Type OrderType, AActor* enemyTarget) { NativeCall<void, APrimalDinoCharacter*, EDinoTamedOrder::Type, AActor*>(this, "APrimalCharacter.ServerDinoOrder_Implementation", aDino, OrderType, enemyTarget); }

    void ServerPlayFireBallistaAnimation_Implementation() { NativeCall<void>(this, "APrimalCharacter.ServerPlayFireBallistaAnimation_Implementation"); }

    void ServerPrepareForSeamlessTravel_Implementation() { NativeCall<void>(this, "APrimalCharacter.ServerPrepareForSeamlessTravel_Implementation"); }

    void ServerSeatingStructureAction_Implementation(char ActionNumber) { NativeCall<void, char>(this, "APrimalCharacter.ServerSeatingStructureAction_Implementation", ActionNumber); }

    void ServerSetRunning_Implementation(bool bNewRunning) { NativeCall<void, bool>(this, "APrimalCharacter.ServerSetRunning_Implementation", bNewRunning); }

    void ServerSetTargeting_Implementation(bool bNewTargeting, bool bForceForShield, bool bSkipShieldAnim) { NativeCall<void, bool, bool, bool>(this, "APrimalCharacter.ServerSetTargeting_Implementation", bNewTargeting, bForceForShield, bSkipShieldAnim); }

    void ServerToClientsPlayFireBallistaAnimation_Implementation() { NativeCall<void>(this, "APrimalCharacter.ServerToClientsPlayFireBallistaAnimation_Implementation"); }

    void ServerTryPoop_Implementation() { NativeCall<void>(this, "APrimalCharacter.ServerTryPoop_Implementation"); }

    void SetBase(UPrimitiveComponent* NewBaseComponent, FName BoneName, bool bNotifyPawn) { NativeCall<void, UPrimitiveComponent*, FName, bool>(this, "APrimalCharacter.SetBase", NewBaseComponent, BoneName, bNotifyPawn); }

    void SetBasedOntoRaft(APrimalDinoCharacter* theDino) { NativeCall<void, APrimalDinoCharacter*>(this, "APrimalCharacter.SetBasedOntoRaft", theDino); }

    void SetBoundsScale(float NewScale) { NativeCall<void, float>(this, "APrimalCharacter.SetBoundsScale", NewScale); }

    void SetCharacterMeshesMaterialScalarParamValue(FName ParamName, float Value) { NativeCall<void, FName, float>(this, "APrimalCharacter.SetCharacterMeshesMaterialScalarParamValue", ParamName, Value); }

    void SetDeath(bool bForceRagdoll) { NativeCall<void, bool>(this, "APrimalCharacter.SetDeath", bForceRagdoll); }

    void SetDynamicMusic(USoundBase* newMusic) { NativeCall<void, USoundBase*>(this, "APrimalCharacter.SetDynamicMusic", newMusic); }

    void SetEnableIK(bool bEnable, bool bForceOnDedicated) { NativeCall<void, bool, bool>(this, "APrimalCharacter.SetEnableIK", bEnable, bForceOnDedicated); }

    float SetHealth(float newHealth) { return NativeCall<float, float>(this, "APrimalCharacter.SetHealth", newHealth); }

    void SetRagdollReplication(bool Enabled) { NativeCall<void, bool>(this, "APrimalCharacter.SetRagdollReplication", Enabled); }

    void SetRunning(bool bNewRunning) { NativeCall<void, bool>(this, "APrimalCharacter.SetRunning", bNewRunning); }

    void SetShieldState(bool bLowerShield, bool bSkipShieldAnim) { NativeCall<void, bool, bool>(this, "APrimalCharacter.SetShieldState", bLowerShield, bSkipShieldAnim); }

    void SetSleeping(bool bSleeping, bool bUseRagdollLocationOffset) { NativeCall<void, bool, bool>(this, "APrimalCharacter.SetSleeping", bSleeping, bUseRagdollLocationOffset); }

    void SetTargeting(bool bNewTargeting, bool bForceForShield, bool bSkipShieldAnim) { NativeCall<void, bool, bool, bool>(this, "APrimalCharacter.SetTargeting", bNewTargeting, bForceForShield, bSkipShieldAnim); }

    bool ShouldAttackStopMoveCollapsing() { return NativeCall<bool>(this, "APrimalCharacter.ShouldAttackStopMoveCollapsing"); }

    bool ShouldUseWaveLocking(bool bForceCheck) { return NativeCall<bool, bool>(this, "APrimalCharacter.ShouldUseWaveLocking", bForceCheck); }

    bool SimulatedPreventBasedPhysics() { return NativeCall<bool>(this, "APrimalCharacter.SimulatedPreventBasedPhysics"); }

    void SleepBodies() { NativeCall<void>(this, "APrimalCharacter.SleepBodies"); }

    TArray<AActor*>* SortActorsByRelativeYaw(TArray<AActor*>* result, TArray<AActor*>* actors) { return NativeCall<TArray<AActor*>*, TArray<AActor*>*, TArray<AActor*>*>(this, "APrimalCharacter.SortActorsByRelativeYaw", result, actors); }

    void StartForceSkelUpdate(float ForTime, bool bForceUpdateMesh, bool bServerOnly) { NativeCall<void, float, bool, bool>(this, "APrimalCharacter.StartForceSkelUpdate", ForTime, bForceUpdateMesh, bServerOnly); }

    void StartHitStaggering(float staggeringTime) { NativeCall<void, float>(this, "APrimalCharacter.StartHitStaggering", staggeringTime); }

    void StartStaggering(float staggeringTime, float PlayStaggerAnimAfterDelay, bool bPlayStaggerAnim) { NativeCall<void, float, float, bool>(this, "APrimalCharacter.StartStaggering", staggeringTime, PlayStaggerAnimAfterDelay, bPlayStaggerAnim); }

    void StartedFiringWeapon(bool bPrimaryFire) { NativeCall<void, bool>(this, "APrimalCharacter.StartedFiringWeapon", bPrimaryFire); }

    void Stasis() { NativeCall<void>(this, "APrimalCharacter.Stasis"); }

    static void StaticRemoveCharacterSnapshot(UPrimalItem* Item, AActor* From) { NativeCall<void, UPrimalItem*, AActor*>(nullptr, "APrimalCharacter.StaticRemoveCharacterSnapshot", Item, From); }

    void StopAllAnimMontages(float BlendOutTime) { NativeCall<void, float>(this, "APrimalCharacter.StopAllAnimMontages", 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 StopAnimExFPV(UAnimMontage* AnimMontage, bool bReplicate, bool bReplicateToOwner, float BlendOutTime) { NativeCall<void, UAnimMontage*, bool, bool, float>(this, "APrimalCharacter.StopAnimExFPV", AnimMontage, bReplicate, bReplicateToOwner, BlendOutTime); }

    void StopAnimMontage(UAnimMontage* AnimMontage) { NativeCall<void, UAnimMontage*>(this, "APrimalCharacter.StopAnimMontage", AnimMontage); }

    void StopHitStaggering() { NativeCall<void>(this, "APrimalCharacter.StopHitStaggering"); }

    void StopStaggering() { NativeCall<void>(this, "APrimalCharacter.StopStaggering"); }

    void Suicide() { NativeCall<void>(this, "APrimalCharacter.Suicide"); }

    void TagFriendlyStructures() { NativeCall<void>(this, "APrimalCharacter.TagFriendlyStructures"); }

    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 TakeFallingDamage(FHitResult* Hit) { NativeCall<void, FHitResult*>(this, "APrimalCharacter.TakeFallingDamage", Hit); }

    void TakeSeatingStructure(APrimalStructureSeating* InSeatingStructure, int SeatNumber, bool bLockedToSeat) { NativeCall<void, APrimalStructureSeating*, int, bool>(this, "APrimalCharacter.TakeSeatingStructure", InSeatingStructure, SeatNumber, bLockedToSeat); }

    void TeleportSucceeded(bool bIsATest, bool bSimpleTeleport) { NativeCall<void, bool, bool>(this, "APrimalCharacter.TeleportSucceeded", bIsATest, bSimpleTeleport); }

    bool TeleportTo(FVector* DestLocation, FRotator* DestRotation, bool bIsATest, bool bNoCheck) { return NativeCall<bool, FVector*, FRotator*, bool, bool>(this, "APrimalCharacter.TeleportTo", DestLocation, DestRotation, bIsATest, bNoCheck); }

    void TeleportToTargetLocation(FVector AtLocation, APrimalRaft* OnRaft) { NativeCall<void, FVector, APrimalRaft*>(this, "APrimalCharacter.TeleportToTargetLocation", AtLocation, OnRaft); }

    void Tick(float DeltaSeconds) { NativeCall<void, float>(this, "APrimalCharacter.Tick", DeltaSeconds); }

    void TickMovementComponent(float DeltaTime) { NativeCall<void, float>(this, "APrimalCharacter.TickMovementComponent", DeltaTime); }

    void TogglePerspective() { NativeCall<void>(this, "APrimalCharacter.TogglePerspective"); }

    bool TraceForOpenTeleportLocation(FVector AtFloorLocation, FVector* OpenLocation, APrimalDinoCharacter* OnDino, bool bSnapToGround, float GroundCheckDistance) { return NativeCall<bool, FVector, FVector*, APrimalDinoCharacter*, bool, float>(this, "APrimalCharacter.TraceForOpenTeleportLocation", AtFloorLocation, OpenLocation, OnDino, bSnapToGround, GroundCheckDistance); }

    bool TryAccessInventory() { return NativeCall<bool>(this, "APrimalCharacter.TryAccessInventory"); }

    void TryAccessInventoryWrapper() { NativeCall<void>(this, "APrimalCharacter.TryAccessInventoryWrapper"); }

    void TryCallAttackTarget() { NativeCall<void>(this, "APrimalCharacter.TryCallAttackTarget"); }

    void TryCallFollowDistanceCycleOne() { NativeCall<void>(this, "APrimalCharacter.TryCallFollowDistanceCycleOne"); }

    void TryCallFollowOne() { NativeCall<void>(this, "APrimalCharacter.TryCallFollowOne"); }

    void TryCallMoveTo() { NativeCall<void>(this, "APrimalCharacter.TryCallMoveTo"); }

    void TryCallStayOne() { NativeCall<void>(this, "APrimalCharacter.TryCallStayOne"); }

    void TryCutEnemyGrapplingCable() { NativeCall<void>(this, "APrimalCharacter.TryCutEnemyGrapplingCable"); }

    void TryDragCharacter(APrimalCharacter* Character) { NativeCall<void, APrimalCharacter*>(this, "APrimalCharacter.TryDragCharacter", Character); }

    void TryGiveDefaultWeapon() { NativeCall<void>(this, "APrimalCharacter.TryGiveDefaultWeapon"); }

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

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

    void TryPoop() { NativeCall<void>(this, "APrimalCharacter.TryPoop"); }

    bool TryTeleportToBasedShipDeck(const int* ToDeckIndex, APlayerController* ForPC) { return NativeCall<bool, const int*, APlayerController*>(this, "APrimalCharacter.TryTeleportToBasedShipDeck", ToDeckIndex, ForPC); }

    bool TryTeleportToTargetLocation(APrimalRaft* OnRaft, FVector TargetLocation, APlayerController* ForPC) { return NativeCall<bool, APrimalRaft*, FVector, APlayerController*>(this, "APrimalCharacter.TryTeleportToTargetLocation", OnRaft, TargetLocation, ForPC); }

    void TurnAtRate(float Val) { NativeCall<void, float>(this, "APrimalCharacter.TurnAtRate", Val); }

    void TurnInput(float Val) { NativeCall<void, float>(this, "APrimalCharacter.TurnInput", Val); }

    void UnPossessed() { NativeCall<void>(this, "APrimalCharacter.UnPossessed"); }

    void UnProne(bool bClientSimulation) { NativeCall<void, bool>(this, "APrimalCharacter.UnProne", bClientSimulation); }

    void UnequipPrimalItemSideWeapon(bool bIsPrimaryWeapon, bool bIsSwitch) { NativeCall<void, bool, bool>(this, "APrimalCharacter.UnequipPrimalItemSideWeapon", bIsPrimaryWeapon, bIsSwitch); }

    void UnmarkAbortedForSeamlessTravel() { NativeCall<void>(this, "APrimalCharacter.UnmarkAbortedForSeamlessTravel"); }

    void Unstasis() { NativeCall<void>(this, "APrimalCharacter.Unstasis"); }

    void UpdateBasedOnRaft() { NativeCall<void>(this, "APrimalCharacter.UpdateBasedOnRaft"); }

    void UpdateBasedOnRaftInventory(float DeltaSeconds) { NativeCall<void, float>(this, "APrimalCharacter.UpdateBasedOnRaftInventory", DeltaSeconds); }

    void UpdateDragging() { NativeCall<void>(this, "APrimalCharacter.UpdateDragging"); }

    void UpdateIK() { NativeCall<void>(this, "APrimalCharacter.UpdateIK"); }

    void UpdateNetDynamicMusic() { NativeCall<void>(this, "APrimalCharacter.UpdateNetDynamicMusic"); }

    void UpdateRunSounds(bool bNewRunning) { NativeCall<void, bool>(this, "APrimalCharacter.UpdateRunSounds", bNewRunning); }

    void UpdateSimulatedPosition(FVector* NewLocation, FRotator* NewRotation) { NativeCall<void, FVector*, FRotator*>(this, "APrimalCharacter.UpdateSimulatedPosition", NewLocation, NewRotation); }

    void UpdateStatusComponent(float DeltaSeconds) { NativeCall<void, float>(this, "APrimalCharacter.UpdateStatusComponent", DeltaSeconds); }

    void UpdateStencilValues() { NativeCall<void>(this, "APrimalCharacter.UpdateStencilValues"); }

    void UpdateSwimmingState() { NativeCall<void>(this, "APrimalCharacter.UpdateSwimmingState"); }

    void UpdateTribeName(FString NewTribeName) { NativeCall<void, FString>(this, "APrimalCharacter.UpdateTribeName", NewTribeName); }

    void UpdateWindedState() { NativeCall<void>(this, "APrimalCharacter.UpdateWindedState"); }

    bool UseClearOnConsumeInput() { return NativeCall<bool>(this, "APrimalCharacter.UseClearOnConsumeInput"); }

    bool UseFastTurretTargeting() { return NativeCall<bool>(this, "APrimalCharacter.UseFastTurretTargeting"); }

    void ValidatePaintingComponentOctree() { NativeCall<void>(this, "APrimalCharacter.ValidatePaintingComponentOctree"); }

    void WeaponClampRotation_Implementation(FRotator* InputRot, FRotator CurrentRot, float InputDeltaTime) { NativeCall<void, FRotator*, FRotator, float>(this, "APrimalCharacter.WeaponClampRotation_Implementation", InputRot, CurrentRot, InputDeltaTime); }

    void ZoomIn() { NativeCall<void>(this, "APrimalCharacter.ZoomIn"); }

    void ZoomOut() { NativeCall<void>(this, "APrimalCharacter.ZoomOut"); }

    void ClientHandleNetDestroy() { NativeCall<void>(this, "APrimalCharacter.ClientHandleNetDestroy"); }

    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 AllowBlockingWithShield() { return NativeCall<bool>(this, "APrimalCharacter.AllowBlockingWithShield"); }

    void BPAddedAttachmentsForItem(UPrimalItem* anItem) { NativeCall<void, UPrimalItem*>(this, "APrimalCharacter.BPAddedAttachmentsForItem", anItem); }

    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); }

    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 BPCanNotifyTeamAggroAI(APrimalDinoCharacter* Dino) { return NativeCall<bool, APrimalDinoCharacter*>(this, "APrimalCharacter.BPCanNotifyTeamAggroAI", Dino); }

    bool BPCanStagger() { return NativeCall<bool>(this, "APrimalCharacter.BPCanStagger"); }

    void BPCharacterDetach() { NativeCall<void>(this, "APrimalCharacter.BPCharacterDetach"); }

    void BPCharacterSleeped() { NativeCall<void>(this, "APrimalCharacter.BPCharacterSleeped"); }

    void BPCharacterUnsleeped() { NativeCall<void>(this, "APrimalCharacter.BPCharacterUnsleeped"); }

    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"); }

    bool BPHandlePoop() { return NativeCall<bool>(this, "APrimalCharacter.BPHandlePoop"); }

    bool BPHandleRightShoulderButton() { return NativeCall<bool>(this, "APrimalCharacter.BPHandleRightShoulderButton"); }

    void BPInventoryItemRepairedOrBroken(UPrimalItem* TheItem, bool bIsBroken) { NativeCall<void, UPrimalItem*, bool>(this, "APrimalCharacter.BPInventoryItemRepairedOrBroken", TheItem, bIsBroken); }

    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 BPModifyViewHitDir(APrimalCharacter* viewingCharacter, float InViewHitDir) { return NativeCall<float, APrimalCharacter*, float>(this, "APrimalCharacter.BPModifyViewHitDir", viewingCharacter, InViewHitDir); }

    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, EPrimalCharacterStatusValue::Type StatType) { NativeCall<void, int, EPrimalCharacterStatusValue::Type>(this, "APrimalCharacter.BPNotifyLevelUp", ExtraCharacterLevel, StatType); }

    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); }

    void BPOnMovementModeChangedNotify() { NativeCall<void>(this, "APrimalCharacter.BPOnMovementModeChangedNotify"); }

    void BPOnWeaponEquipped() { NativeCall<void>(this, "APrimalCharacter.BPOnWeaponEquipped"); }

    void BPOnWeaponStartedAttack(int weaponAttackIndex, bool useAltAnim) { NativeCall<void, int, bool>(this, "APrimalCharacter.BPOnWeaponStartedAttack", weaponAttackIndex, useAltAnim); }

    FVector* BPOverrideCharacterNewFallVelocity(FVector* result, FVector* InitialVelocity, FVector* Gravity, float DeltaTime) { return NativeCall<FVector*, FVector*, FVector*, FVector*, float>(this, "APrimalCharacter.BPOverrideCharacterNewFallVelocity", result, InitialVelocity, Gravity, DeltaTime); }

    bool BPOverrideFPVViewLocation(APrimalCharacter* viewingCharacter) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalCharacter.BPOverrideFPVViewLocation", viewingCharacter); }

    bool BPPreventInputType(EPrimalCharacterInputType::Type inputType) { return NativeCall<bool, EPrimalCharacterInputType::Type>(this, "APrimalCharacter.BPPreventInputType", inputType); }

    bool BPPreventStasis() { return NativeCall<bool>(this, "APrimalCharacter.BPPreventStasis"); }

    void BPRemoveCharacterSnapshot(UPrimalItem* Item, AActor* From) { NativeCall<void, UPrimalItem*, AActor*>(this, "APrimalCharacter.BPRemoveCharacterSnapshot", Item, From); }

    bool BPShouldLimitForwardDirection() { return NativeCall<bool>(this, "APrimalCharacter.BPShouldLimitForwardDirection"); }

    void BPTimerNonDedicated() { NativeCall<void>(this, "APrimalCharacter.BPTimerNonDedicated"); }

    void BPTimerServer() { NativeCall<void>(this, "APrimalCharacter.BPTimerServer"); }

    bool BP_CanTeleportOntoRaft(APrimalRaft* OnRaft, APlayerController* ForPC) { return NativeCall<bool, APrimalRaft*, APlayerController*>(this, "APrimalCharacter.BP_CanTeleportOntoRaft", OnRaft, ForPC); }

    APrimalRaft* BP_FindClosestTeleportRaft(APlayerController* ForPC, UPrimitiveComponent* BasedOn) { return NativeCall<APrimalRaft*, APlayerController*, UPrimitiveComponent*>(this, "APrimalCharacter.BP_FindClosestTeleportRaft", ForPC, BasedOn); }

    bool BP_ForceAllowAddBuffOfClass(TSubclassOf<APrimalBuff> BuffClass) { return NativeCall<bool, TSubclassOf<APrimalBuff>>(this, "APrimalCharacter.BP_ForceAllowAddBuffOfClass", BuffClass); }

    bool BP_IsCharacterHardAttached(bool bIgnoreRiding, bool bIgnoreCarried) { return NativeCall<bool, bool, bool>(this, "APrimalCharacter.BP_IsCharacterHardAttached", bIgnoreRiding, bIgnoreCarried); }

    void BP_OnIgnoredMoveToOrder(APlayerController* FromPC) { NativeCall<void, APlayerController*>(this, "APrimalCharacter.BP_OnIgnoredMoveToOrder", FromPC); }

    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_OnTeleportOntoRaft(APrimalRaft* OntoRaft) { NativeCall<void, APrimalRaft*>(this, "APrimalCharacter.BP_OnTeleportOntoRaft", OntoRaft); }

    void BP_OnZoomIn() { NativeCall<void>(this, "APrimalCharacter.BP_OnZoomIn"); }

    void BP_OnZoomOut() { NativeCall<void>(this, "APrimalCharacter.BP_OnZoomOut"); }

    void ChangedAnimationBlueprint() { NativeCall<void>(this, "APrimalCharacter.ChangedAnimationBlueprint"); }

    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 ClientStopAnimationFPV(UAnimMontage* AnimMontage, bool bStopOnOwner, float BlendOutTime) { NativeCall<void, UAnimMontage*, bool, float>(this, "APrimalCharacter.ClientStopAnimationFPV", AnimMontage, bStopOnOwner, BlendOutTime); }

    void DeathHarvestingFadeOut() { NativeCall<void>(this, "APrimalCharacter.DeathHarvestingFadeOut"); }

    void DidTeleport(FVector newLoc, FRotator newRot) { NativeCall<void, FVector, FRotator>(this, "APrimalCharacter.DidTeleport", newLoc, newRot); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "APrimalCharacter.GetPrivateStaticClass", Package); }

    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 NetReleaseSeatingStructure() { NativeCall<void>(this, "APrimalCharacter.NetReleaseSeatingStructure"); }

    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 Net_OnIsStaggering(bool bNewStaggering, float PlayAnimAfterDelay, bool bPlayStaggerAnim) { NativeCall<void, bool, float, bool>(this, "APrimalCharacter.Net_OnIsStaggering", bNewStaggering, PlayAnimAfterDelay, bPlayStaggerAnim); }

    void OnActorEnterWater(USceneComponent* Component, FVector OverlapLocation, FVector OverlapVelocity) { NativeCall<void, USceneComponent*, FVector, FVector>(this, "APrimalCharacter.OnActorEnterWater", Component, OverlapLocation, OverlapVelocity); }

    void OnActorExitWater(USceneComponent* Component, FVector OverlapLocation, FVector OverlapVelocity) { NativeCall<void, USceneComponent*, FVector, FVector>(this, "APrimalCharacter.OnActorExitWater", Component, OverlapLocation, OverlapVelocity); }

    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"); }

    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); }

    FString* PlayerCommand(FString* result, FString* TheCommand) { return NativeCall<FString*, FString*, FString*>(this, "APrimalCharacter.PlayerCommand", result, TheCommand); }

    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 ServerCallMoveTo(FVector MoveToLoc, AActor* TargetActor) { NativeCall<void, FVector, AActor*>(this, "APrimalCharacter.ServerCallMoveTo", MoveToLoc, TargetActor); }

    void ServerCallMoveToRaft(FVector MoveToRelLoc, APrimalRaft* TargetRaft, int ToDeckIndex) { NativeCall<void, FVector, APrimalRaft*, int>(this, "APrimalCharacter.ServerCallMoveToRaft", MoveToRelLoc, TargetRaft, ToDeckIndex); }

    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 ServerDinoOrder(APrimalDinoCharacter* aDino, EDinoTamedOrder::Type OrderType, AActor* target) { NativeCall<void, APrimalDinoCharacter*, EDinoTamedOrder::Type, AActor*>(this, "APrimalCharacter.ServerDinoOrder", aDino, OrderType, target); }

    void ServerGiveDefaultWeapon(bool bOnlyGiveDefaultWeapon) { NativeCall<void, bool>(this, "APrimalCharacter.ServerGiveDefaultWeapon", bOnlyGiveDefaultWeapon); }

    void ServerPlayFireBallistaAnimation() { NativeCall<void>(this, "APrimalCharacter.ServerPlayFireBallistaAnimation"); }

    void ServerSetRunning(bool bNewRunning) { NativeCall<void, bool>(this, "APrimalCharacter.ServerSetRunning", bNewRunning); }

    void ServerSetTargeting(bool bNewTargeting, bool bForceForShield, bool bSkipShieldAnim) { NativeCall<void, bool, bool, bool>(this, "APrimalCharacter.ServerSetTargeting", bNewTargeting, bForceForShield, bSkipShieldAnim); }

    void ServerToClientsPlayFireBallistaAnimation() { NativeCall<void>(this, "APrimalCharacter.ServerToClientsPlayFireBallistaAnimation"); }

    void ServerTryPoop() { NativeCall<void>(this, "APrimalCharacter.ServerTryPoop"); }

    static void StaticRegisterNativesAPrimalCharacter() { NativeCall<void>(nullptr, "APrimalCharacter.StaticRegisterNativesAPrimalCharacter"); }

    void WeaponClampRotation(FRotator* InputRot, FRotator CurrentRot, float InputDeltaTime) { NativeCall<void, FRotator*, FRotator, float>(this, "APrimalCharacter.WeaponClampRotation", InputRot, CurrentRot, InputDeltaTime); }

    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); }

};


struct AShooterCharacter : APrimalCharacter

{

    TArray<FTransponderInfo>& ClientTranspondersInfoField() { return *GetNativePointerField<TArray<FTransponderInfo>*>(this, "AShooterCharacter.ClientTranspondersInfo"); }

    FItemNetID& PreviousWeaponToReloadAllField() { return *GetNativePointerField<FItemNetID*>(this, "AShooterCharacter.PreviousWeaponToReloadAll"); }

    TArray<FItemNetID>& WeaponsToReloadAllField() { return *GetNativePointerField<TArray<FItemNetID>*>(this, "AShooterCharacter.WeaponsToReloadAll"); }

    long double& ReloadLastAttemptedWeaponSwitchTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.ReloadLastAttemptedWeaponSwitchTime"); }

    long double& ReloadLastAttemptedWeaponReloadTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.ReloadLastAttemptedWeaponReloadTime"); }

    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* 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& LastStartedTalkingTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastStartedTalkingTime"); }

    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& bBendArmLengthFactorField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.bBendArmLengthFactor"); }

    float& BendMinAngleField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.BendMinAngle"); }

    float& BendMaxAngleField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.BendMaxAngle"); }

    float& BobMaxMovementSpeedField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.BobMaxMovementSpeed"); }

    float& WeaponBobMaxMovementSpeedField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.WeaponBobMaxMovementSpeed"); }

    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"); }

    FString& PlayerNameField() { return *GetNativePointerField<FString*>(this, "AShooterCharacter.PlayerName"); }

    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"); }

    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"); }

    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"); }

    float& TargetingSpeedModifierField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.TargetingSpeedModifier"); }

    float& LowHealthSoundPercentageField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.LowHealthSoundPercentage"); }

    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"); }

    USoundMix* BelowDeckMixerField() { return *GetNativePointerField<USoundMix**>(this, "AShooterCharacter.BelowDeckMixer"); }

    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"); }

    FItemNetID& PreMapWeaponItemNetIDSecondaryField() { return *GetNativePointerField<FItemNetID*>(this, "AShooterCharacter.PreMapWeaponItemNetIDSecondary"); }

    float& PreviousAgeField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.PreviousAge"); }

    unsigned __int64& LinkedPlayerDataIDField() { return *GetNativePointerField<unsigned __int64*>(this, "AShooterCharacter.LinkedPlayerDataID"); }

    long double& LastTimeInFallingField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastTimeInFalling"); }

    long double& TimeSinceLastControllerField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.TimeSinceLastController"); }

    TWeakObjectPtr<AController>& LastControllerField() { return *GetNativePointerField<TWeakObjectPtr<AController>*>(this, "AShooterCharacter.LastController"); }

    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& PreRidingWeaponItemNetIDSecondaryField() { return *GetNativePointerField<FItemNetID*>(this, "AShooterCharacter.PreRidingWeaponItemNetIDSecondary"); }

    FItemNetID& PreInventoryWeaponItemNetIDField() { return *GetNativePointerField<FItemNetID*>(this, "AShooterCharacter.PreInventoryWeaponItemNetID"); }

    FItemNetID& PreInventoryWeaponItemNetIDSecondaryField() { return *GetNativePointerField<FItemNetID*>(this, "AShooterCharacter.PreInventoryWeaponItemNetIDSecondary"); }

    UAnimSequence* ViewingInventoryAnimationField() { return *GetNativePointerField<UAnimSequence**>(this, "AShooterCharacter.ViewingInventoryAnimation"); }

    UAnimSequence* DefaultDinoRidingAnimationField() { return *GetNativePointerField<UAnimSequence**>(this, "AShooterCharacter.DefaultDinoRidingAnimation"); }

    UAnimSequence* DefaultDinoRidingMoveAnimationField() { return *GetNativePointerField<UAnimSequence**>(this, "AShooterCharacter.DefaultDinoRidingMoveAnimation"); }

    long double& FastTravellingStartTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.FastTravellingStartTime"); }

    FItemNetID& LastReloadAllItemIDField() { return *GetNativePointerField<FItemNetID*>(this, "AShooterCharacter.LastReloadAllItemID"); }

    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"); }

    float& MuscleToneField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.MuscleTone"); }

    float& BodyfatField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.Bodyfat"); }

    long double& BornAtNetworkTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.BornAtNetworkTime"); }

    long double& PlayerDiedAtNetworkTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.PlayerDiedAtNetworkTime"); }

    FieldArray<float, 66> BonePresetsField() { return { this, "AShooterCharacter.BonePresets" }; }

    float& FullAgeGameTimeIntervalField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.FullAgeGameTimeInterval"); }

    float& ApplyAgeDeltaThresholdField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.ApplyAgeDeltaThreshold"); }

    float& AgeMinDisplayYearsField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.AgeMinDisplayYears"); }

    float& AgeMaxDisplayYearsField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.AgeMaxDisplayYears"); }

    float& WetnessField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.Wetness"); }

    float& InterpolatedWetsField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.InterpolatedWets"); }

    float& WetnessDrySpeedField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.WetnessDrySpeed"); }

    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"); }

    unsigned int& UniqueNetIdTypeHashField() { return *GetNativePointerField<unsigned int*>(this, "AShooterCharacter.UniqueNetIdTypeHash"); }

    FString& UniqueNetIdStrField() { return *GetNativePointerField<FString*>(this, "AShooterCharacter.UniqueNetIdStr"); }

    long double& LastUseHarvestTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastUseHarvestTime"); }

    UAnimMontage* SpawnAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.SpawnAnim"); }

    UAnimMontage* FirstSpawnAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.FirstSpawnAnim"); }

    FVector& LastStasisCastPositionField() { return *GetNativePointerField<FVector*>(this, "AShooterCharacter.LastStasisCastPosition"); }

    bool& bWasHostPlayerField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bWasHostPlayer"); }

    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"); }

    float& CurrentControlledBallistaYawField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.CurrentControlledBallistaYaw"); }

    bool& bIsServerAdminField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bIsServerAdmin"); }

    float& WetMaximumTemperatureReductionField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.WetMaximumTemperatureReduction"); }

    float& WetMinimumTemperatureReductionField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.WetMinimumTemperatureReduction"); }

    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"); }

    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"); }

    unsigned __int64& TradingInvitePlayerIDField() { return *GetNativePointerField<unsigned __int64*>(this, "AShooterCharacter.TradingInvitePlayerID"); }

    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& HeadHairGrowthParamQuantizationField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.HeadHairGrowthParamQuantization"); }

    float& FacialHairGrowthParamQuantizationField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.FacialHairGrowthParamQuantization"); }

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

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

    FLinearColor& OriginalHairColorField() { return *GetNativePointerField<FLinearColor*>(this, "AShooterCharacter.OriginalHairColor"); }

    float& GlobalWindHairLerpField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.GlobalWindHairLerp"); }

    float& LastGlobalWindHairLerpField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.LastGlobalWindHairLerp"); }

    float& GlobalDynamicsHairLerpField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.GlobalDynamicsHairLerp"); }

    float& LastGlobalDynamicsHairLerpField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.LastGlobalDynamicsHairLerp"); }

    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"); }

    bool& bAwaitingSeamlessTravelControllerField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bAwaitingSeamlessTravelController"); }

    bool& bModifiedEyeHeightField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bModifiedEyeHeight"); }

    bool& bSkipNextLocalPossessedByField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bSkipNextLocalPossessedBy"); }

    TEnumAsByte<enum EPrimalStatsValueTypes::Type>& BestInstantShotResultField() { return *GetNativePointerField<TEnumAsByte<enum EPrimalStatsValueTypes::Type>*>(this, "AShooterCharacter.BestInstantShotResult"); }

    TArray<FFeatCooldown>& FeatCooldownsField() { return *GetNativePointerField<TArray<FFeatCooldown>*>(this, "AShooterCharacter.FeatCooldowns"); }

    long double& LastTimeReleasedAllowFPVStructureField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastTimeReleasedAllowFPVStructure"); }

    long double& LastGrapHookDetachTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastGrapHookDetachTime"); }

    TMap<APrimalRaft*, FRelativePositionEntry, FDefaultSetAllocator, TDefaultMapKeyFuncs<APrimalRaft*, FRelativePositionEntry, 0> > ShipsRelativePositionMapField() { return *GetNativePointerField<TMap<APrimalRaft*, FRelativePositionEntry, FDefaultSetAllocator, TDefaultMapKeyFuncs<APrimalRaft*, FRelativePositionEntry, 0> >*>(this, "AShooterCharacter.ShipsRelativePositionMap"); }

    long double& LastCombatActionTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastCombatActionTime"); }

    long double& TimeStartedLockOnField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.TimeStartedLockOn"); }

    AActor* LockOnTargetField() { return *GetNativePointerField<AActor**>(this, "AShooterCharacter.LockOnTarget"); }

    int& ReloadMiniGameSuccessCounterField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.ReloadMiniGameSuccessCounter"); }

    float& WalkSpeedThresholdField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.WalkSpeedThreshold"); }

    float& MinRunningSpeedModifierField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.MinRunningSpeedModifier"); }

    FHandIkTarget& LeftHandIkTargetField() { return *GetNativePointerField<FHandIkTarget*>(this, "AShooterCharacter.LeftHandIkTarget"); }

    FHandIkTarget& RightHandIkTargetField() { return *GetNativePointerField<FHandIkTarget*>(this, "AShooterCharacter.RightHandIkTarget"); }

    FName& RightShoulderBoneNameField() { return *GetNativePointerField<FName*>(this, "AShooterCharacter.RightShoulderBoneName"); }

    FName& RightTipBoneNameField() { return *GetNativePointerField<FName*>(this, "AShooterCharacter.RightTipBoneName"); }

    FName& LeftShoulderBoneNameField() { return *GetNativePointerField<FName*>(this, "AShooterCharacter.LeftShoulderBoneName"); }

    FName& LeftTipBoneNameField() { return *GetNativePointerField<FName*>(this, "AShooterCharacter.LeftTipBoneName"); }

    FName& TorsoBoneNameField() { return *GetNativePointerField<FName*>(this, "AShooterCharacter.TorsoBoneName"); }

    float& ForwardBindingAlphaField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.ForwardBindingAlpha"); }

    float& ForwardBindingInterpSpeedField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.ForwardBindingInterpSpeed"); }

    FieldArray<float, 8> DirectionalSpeedMultipliersField() { return { this, "AShooterCharacter.DirectionalSpeedMultipliers" }; }

    float& TimeInVitaEqField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.TimeInVitaEq"); }

    float& TotalTimeForVitaEqField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.TotalTimeForVitaEq"); }

    float& CurrentForwardBindingAlphaField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.CurrentForwardBindingAlpha"); }

    FItemNetID& PreviousWeaponItemIDField() { return *GetNativePointerField<FItemNetID*>(this, "AShooterCharacter.PreviousWeaponItemID"); }

    APrimalDinoCharacter* TransitionMountedDinoField() { return *GetNativePointerField<APrimalDinoCharacter**>(this, "AShooterCharacter.TransitionMountedDino"); }

    int& CurrentDiscoveryZoneIDField() { return *GetNativePointerField<int*>(this, "AShooterCharacter.CurrentDiscoveryZoneID"); }

    bool& bCurrentDiscoveryZoneAllowSeaField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bCurrentDiscoveryZoneAllowSea"); }

    FieldArray<UTexture2D * [5], 25> PlayerMeshNoEquipmentShrinkageMasksField() { return { this, "AShooterCharacter.PlayerMeshNoEquipmentShrinkageMasks" }; }

    UAnimMontage* FallAsleepAnimField() { return *GetNativePointerField<UAnimMontage**>(this, "AShooterCharacter.FallAsleepAnim"); }

    UPrimalPlayerData* TravellingPlayerDataField() { return *GetNativePointerField<UPrimalPlayerData**>(this, "AShooterCharacter.TravellingPlayerData"); }

    FVector2D& ExtendedInfoTooltipPaddingField() { return *GetNativePointerField<FVector2D*>(this, "AShooterCharacter.ExtendedInfoTooltipPadding"); }

    FVector2D& ExtendedInfoTooltipScaleField() { return *GetNativePointerField<FVector2D*>(this, "AShooterCharacter.ExtendedInfoTooltipScale"); }

    float& ExtendedInfoTooltipCheckRangeField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.ExtendedInfoTooltipCheckRange"); }

    float& LastMaterialAppliedWetnessAmountField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.LastMaterialAppliedWetnessAmount"); }

    APrimalStructureItemContainer* spawnedTradeStructField() { return *GetNativePointerField<APrimalStructureItemContainer**>(this, "AShooterCharacter.spawnedTradeStruct"); }

    long double& LastInvitedToAllianceTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.LastInvitedToAllianceTime"); }

    USoundBase* JumpSoundField() { return *GetNativePointerField<USoundBase**>(this, "AShooterCharacter.JumpSound"); }

    USoundCue* PreviousCharacterStatusStateSoundField() { return *GetNativePointerField<USoundCue**>(this, "AShooterCharacter.PreviousCharacterStatusStateSound"); }

    float& LastTimeSoundPlayedField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.LastTimeSoundPlayed"); }

    bool& bControllerLeavingGameField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bControllerLeavingGame"); }

    float& TimeBetweenStatusStateSoundsField() { return *GetNativePointerField<float*>(this, "AShooterCharacter.TimeBetweenStatusStateSounds"); }

    long double& PossessedAtTimeField() { return *GetNativePointerField<long double*>(this, "AShooterCharacter.PossessedAtTime"); }

    bool& bForceTeleportClientToHostField() { return *GetNativePointerField<bool*>(this, "AShooterCharacter.bForceTeleportClientToHost"); }

    __int64& SeenTutorialBitFlagsField() { return *GetNativePointerField<__int64*>(this, "AShooterCharacter.SeenTutorialBitFlags"); }

    __int64& CachedTutorialBitFlagsKeyField() { return *GetNativePointerField<__int64*>(this, "AShooterCharacter.CachedTutorialBitFlagsKey"); }


    // Bit fields


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

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

    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> 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> bHadGrapHookAttachActor() { return { this, "AShooterCharacter.bHadGrapHookAttachActor" }; }

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

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

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

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

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

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

    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> bHideAllMultiuseSelectors() { return { this, "AShooterCharacter.bHideAllMultiuseSelectors" }; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


    // Functions


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

    bool BuffsPreventFirstPerson() { return NativeCall<bool>(this, "AShooterCharacter.BuffsPreventFirstPerson"); }

    void AddFeatCooldown(TSubclassOf<APrimalBuff> FeatClass) { NativeCall<void, TSubclassOf<APrimalBuff>>(this, "AShooterCharacter.AddFeatCooldown", FeatClass); }

    void AdjustDamage(float* Damage, FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { NativeCall<void, float*, FDamageEvent*, AController*, AActor*>(this, "AShooterCharacter.AdjustDamage", Damage, DamageEvent, EventInstigator, DamageCauser); }

    bool AllowDinoTargetingRange(FVector* AtLoc, float TargetingRange, AActor* ForAttacker) { return NativeCall<bool, FVector*, float, AActor*>(this, "AShooterCharacter.AllowDinoTargetingRange", AtLoc, TargetingRange, ForAttacker); }

    bool AllowFirstPerson() { return NativeCall<bool>(this, "AShooterCharacter.AllowFirstPerson"); }

    bool AllowGrappling_Implementation() { return NativeCall<bool>(this, "AShooterCharacter.AllowGrappling_Implementation"); }

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

    bool AllowTreadWater() { return NativeCall<bool>(this, "AShooterCharacter.AllowTreadWater"); }

    bool AnimUseAimOffset() { return NativeCall<bool>(this, "AShooterCharacter.AnimUseAimOffset"); }

    static void ApplyAge(UMeshComponent* Mesh, float Age) { NativeCall<void, UMeshComponent*, float>(nullptr, "AShooterCharacter.ApplyAge", Mesh, Age); }

    static void ApplyAgeAndBodyfatHelper(UMeshComponent* Mesh, float Age, float Bodyfat, float MuscleTone, float Wetness) { NativeCall<void, UMeshComponent*, float, float, float, float>(nullptr, "AShooterCharacter.ApplyAgeAndBodyfatHelper", Mesh, Age, Bodyfat, MuscleTone, Wetness); }

    void ApplyBodyColors() { NativeCall<void>(this, "AShooterCharacter.ApplyBodyColors"); }

    void ApplyBoneModifiers() { NativeCall<void>(this, "AShooterCharacter.ApplyBoneModifiers"); }

    void ApplyDamageMomentum(float DamageTaken, FDamageEvent* DamageEvent, APawn* PawnInstigator, AActor* DamageCauser) { NativeCall<void, float, FDamageEvent*, APawn*, AActor*>(this, "AShooterCharacter.ApplyDamageMomentum", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }

    void ApplyEquipmentShrinkageMasks() { NativeCall<void>(this, "AShooterCharacter.ApplyEquipmentShrinkageMasks"); }

    void ApplyFirstPersonBoneModifiers() { NativeCall<void>(this, "AShooterCharacter.ApplyFirstPersonBoneModifiers"); }

    static void ApplyWetnessHelper(UMeshComponent* Mesh, float Wetness) { NativeCall<void, UMeshComponent*, float>(nullptr, "AShooterCharacter.ApplyWetnessHelper", Mesh, Wetness); }

    void AttachToHostCharacter(APawn* HostCharacter) { NativeCall<void, APawn*>(this, "AShooterCharacter.AttachToHostCharacter", HostCharacter); }

    void AttachToLadder_Implementation(USceneComponent* Parent) { NativeCall<void, USceneComponent*>(this, "AShooterCharacter.AttachToLadder_Implementation", Parent); }

    void AuthPostSpawnInit() { NativeCall<void>(this, "AShooterCharacter.AuthPostSpawnInit"); }

    bool BasedOnDynamicActorUseFallingLateralFriction() { return NativeCall<bool>(this, "AShooterCharacter.BasedOnDynamicActorUseFallingLateralFriction"); }

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

    bool BlueprintInitiateTrade(AShooterCharacter* OtherPlayer) { return NativeCall<bool, AShooterCharacter*>(this, "AShooterCharacter.BlueprintInitiateTrade", OtherPlayer); }

    bool CalcIsIndoors() { return NativeCall<bool>(this, "AShooterCharacter.CalcIsIndoors"); }

    FRotator* CalculateForwarBendingAngle(FRotator* result) { return NativeCall<FRotator*, FRotator*>(this, "AShooterCharacter.CalculateForwarBendingAngle", result); }

    FVector* CalculateLookAtHeadLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AShooterCharacter.CalculateLookAtHeadLocation", result); }

    void CallGameStateHandleEvent(FName NameParam, FVector VecParam) { NativeCall<void, FName, FVector>(this, "AShooterCharacter.CallGameStateHandleEvent", NameParam, VecParam); }

    bool CanBeCarried(APrimalCharacter* ByCarrier) { return NativeCall<bool, APrimalCharacter*>(this, "AShooterCharacter.CanBeCarried", ByCarrier); }

    bool CanCrouch() { return NativeCall<bool>(this, "AShooterCharacter.CanCrouch"); }

    bool CanCrouchInternal() { return NativeCall<bool>(this, "AShooterCharacter.CanCrouchInternal"); }

    bool CanDoUsableHarvesting() { return NativeCall<bool>(this, "AShooterCharacter.CanDoUsableHarvesting"); }

    bool CanDragCharacter(APrimalCharacter* Character) { return NativeCall<bool, APrimalCharacter*>(this, "AShooterCharacter.CanDragCharacter", Character); }

    bool CanFire() { return NativeCall<bool>(this, "AShooterCharacter.CanFire"); }

    bool CanGiveCaptainOrders() { return NativeCall<bool>(this, "AShooterCharacter.CanGiveCaptainOrders"); }

    bool CanJumpInternal_Implementation() { return NativeCall<bool>(this, "AShooterCharacter.CanJumpInternal_Implementation"); }

    bool CanProne() { return NativeCall<bool>(this, "AShooterCharacter.CanProne"); }

    bool CanProneInternal() { return NativeCall<bool>(this, "AShooterCharacter.CanProneInternal"); }

    void CancelTrade() { NativeCall<void>(this, "AShooterCharacter.CancelTrade"); }

    void CaptureCharacterSnapshot(UPrimalItem* Item) { NativeCall<void, UPrimalItem*>(this, "AShooterCharacter.CaptureCharacterSnapshot", Item); }

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

    void CheckAndHandleBasedPlayersBeingPushedThroughWalls() { NativeCall<void>(this, "AShooterCharacter.CheckAndHandleBasedPlayersBeingPushedThroughWalls"); }

    void CheckNextSecondaryWeapon() { NativeCall<void>(this, "AShooterCharacter.CheckNextSecondaryWeapon"); }

    bool CheckShipPenetrations() { return NativeCall<bool>(this, "AShooterCharacter.CheckShipPenetrations"); }

    void ClearCarryingDino(bool bFromDino, bool bCancelAnyCarryBuffs) { NativeCall<void, bool, bool>(this, "AShooterCharacter.ClearCarryingDino", bFromDino, bCancelAnyCarryBuffs); }

    void ClearLadderAttachmentInfo() { NativeCall<void>(this, "AShooterCharacter.ClearLadderAttachmentInfo"); }

    void ClearRidingDino(bool bFromDino, int OverrideUnboardDirection) { NativeCall<void, bool, int>(this, "AShooterCharacter.ClearRidingDino", bFromDino, OverrideUnboardDirection); }

    void ClearRidingDinoAsPassenger(bool bFromDino) { NativeCall<void, bool>(this, "AShooterCharacter.ClearRidingDinoAsPassenger", bFromDino); }

    void ClearSpawnAnim() { NativeCall<void>(this, "AShooterCharacter.ClearSpawnAnim"); }

    void ClientClearTribeRequest_Implementation() { NativeCall<void>(this, "AShooterCharacter.ClientClearTribeRequest_Implementation"); }

    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 ClientMultiUse(APlayerController* ForPC, int UseIndex) { NativeCall<void, APlayerController*, int>(this, "AShooterCharacter.ClientMultiUse", ForPC, UseIndex); }

    void ClientNetEndClimbingLadder_Implementation() { NativeCall<void>(this, "AShooterCharacter.ClientNetEndClimbingLadder_Implementation"); }

    void ClientNotifyLevelUp_Implementation() { NativeCall<void>(this, "AShooterCharacter.ClientNotifyLevelUp_Implementation"); }

    void ClientNotifyTribeRequest_Implementation(FString* RequestTribeName, AShooterCharacter* PlayerCharacter) { NativeCall<void, FString*, AShooterCharacter*>(this, "AShooterCharacter.ClientNotifyTribeRequest_Implementation", RequestTribeName, PlayerCharacter); }

    void ClientOnDiscoveredZone_Implementation(int ZoneId, int NewNumZonesDiscovered) { NativeCall<void, int, int>(this, "AShooterCharacter.ClientOnDiscoveredZone_Implementation", ZoneId, NewNumZonesDiscovered); }

    void ClientOrderedAttackTarget_Implementation(AActor* attackTarget) { NativeCall<void, AActor*>(this, "AShooterCharacter.ClientOrderedAttackTarget_Implementation", attackTarget); }

    void ClientOrderedMoveToRaft_Implementation(FVector MoveToRelLoc, APrimalRaft* MoveToRaftRef, int ToDeckIndex) { NativeCall<void, FVector, APrimalRaft*, int>(this, "AShooterCharacter.ClientOrderedMoveToRaft_Implementation", MoveToRelLoc, MoveToRaftRef, ToDeckIndex); }

    void ClientOrderedMoveTo_Implementation(FVector MoveToLoc, AActor* MoveToActorRef) { NativeCall<void, FVector, AActor*>(this, "AShooterCharacter.ClientOrderedMoveTo_Implementation", MoveToLoc, MoveToActorRef); }

    void ClientPlayHarvestAnim_Implementation() { NativeCall<void>(this, "AShooterCharacter.ClientPlayHarvestAnim_Implementation"); }

    void ClientPrepareForSeamlessTravel_Implementation() { NativeCall<void>(this, "AShooterCharacter.ClientPrepareForSeamlessTravel_Implementation"); }

    void ClientProcessLadderAttachment() { NativeCall<void>(this, "AShooterCharacter.ClientProcessLadderAttachment"); }

    void ClientReceiveFeatCooldowns_Implementation(TArray<FFeatCooldown>* theFeatCooldowns) { NativeCall<void, TArray<FFeatCooldown>*>(this, "AShooterCharacter.ClientReceiveFeatCooldowns_Implementation", theFeatCooldowns); }

    void ClientReceiveNextWeaponID_Implementation(FItemNetID theItemID) { NativeCall<void, FItemNetID>(this, "AShooterCharacter.ClientReceiveNextWeaponID_Implementation", theItemID); }

    void ClientSetRotation(FRotator NewRotation) { NativeCall<void, FRotator>(this, "AShooterCharacter.ClientSetRotation", NewRotation); }

    void ClientTradeNotification_Implementation(AShooterCharacter* OtherPlayer) { NativeCall<void, AShooterCharacter*>(this, "AShooterCharacter.ClientTradeNotification_Implementation", OtherPlayer); }

    void ClientUpdateReloadAll() { NativeCall<void>(this, "AShooterCharacter.ClientUpdateReloadAll"); }

    void ClientUpdateTranspondersInfo_Implementation(TArray<FTransponderInfo>* TranspondersInfo, bool bNewData) { NativeCall<void, TArray<FTransponderInfo>*, bool>(this, "AShooterCharacter.ClientUpdateTranspondersInfo_Implementation", TranspondersInfo, bNewData); }

    void ControllerLeavingGame(AShooterPlayerController* theController) { NativeCall<void, AShooterPlayerController*>(this, "AShooterCharacter.ControllerLeavingGame", theController); }

    void DedicatedServerBoneFixup() { NativeCall<void>(this, "AShooterCharacter.DedicatedServerBoneFixup"); }

    void DelayGiveDefaultWeapon(float DelayTime) { NativeCall<void, float>(this, "AShooterCharacter.DelayGiveDefaultWeapon", DelayTime); }

    void DelayedTransitionFixup() { NativeCall<void>(this, "AShooterCharacter.DelayedTransitionFixup"); }

    void Destroyed() { NativeCall<void>(this, "AShooterCharacter.Destroyed"); }

    void DetachFromHostCharacter(APrimalCharacter* HostCharacter) { NativeCall<void, APrimalCharacter*>(this, "AShooterCharacter.DetachFromHostCharacter", HostCharacter); }

    void DetachFromLadder_Implementation(bool bIgnoreOnAutonomousProxy) { NativeCall<void, bool>(this, "AShooterCharacter.DetachFromLadder_Implementation", bIgnoreOnAutonomousProxy); }

    void DetachGrapHookCable_Implementation(bool bDoUpwardsJump, float UpwardsJumpYaw) { NativeCall<void, bool, float>(this, "AShooterCharacter.DetachGrapHookCable_Implementation", bDoUpwardsJump, UpwardsJumpYaw); }

    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 DoCharacterDetachment(bool bIncludeRiding, bool bIncludeCarrying, APrimalBuff* BuffToIgnore) { NativeCall<void, bool, bool, APrimalBuff*>(this, "AShooterCharacter.DoCharacterDetachment", bIncludeRiding, bIncludeCarrying, BuffToIgnore); }

    void DrawFloatingChatMessage(AShooterHUD* HUD, FString Message, long double receivedChatTime) { NativeCall<void, AShooterHUD*, FString, long double>(this, "AShooterCharacter.DrawFloatingChatMessage", HUD, Message, receivedChatTime); }

    void DrawFloatingHUD(AShooterHUD* HUD) { NativeCall<void, AShooterHUD*>(this, "AShooterCharacter.DrawFloatingHUD", HUD); }

    void DrawTranspondersInfo(AShooterHUD* HUD) { NativeCall<void, AShooterHUD*>(this, "AShooterCharacter.DrawTranspondersInfo", HUD); }

    void FaceRotation(FRotator NewControlRotation, float DeltaTime, bool bFromController) { NativeCall<void, FRotator, float, bool>(this, "AShooterCharacter.FaceRotation", NewControlRotation, DeltaTime, bFromController); }

    void FinalLoadedFromSaveGame() { NativeCall<void>(this, "AShooterCharacter.FinalLoadedFromSaveGame"); }

    static AShooterCharacter* FindForPlayerController(AShooterPlayerController* aPC) { return NativeCall<AShooterCharacter*, AShooterPlayerController*>(nullptr, "AShooterCharacter.FindForPlayerController", aPC); }

    void FinishSpawnIntro() { NativeCall<void>(this, "AShooterCharacter.FinishSpawnIntro"); }

    void FinishWeaponSwitch() { NativeCall<void>(this, "AShooterCharacter.FinishWeaponSwitch"); }

    void FiredWeapon() { NativeCall<void>(this, "AShooterCharacter.FiredWeapon"); }

    void ForceGiveDefaultWeapon() { NativeCall<void>(this, "AShooterCharacter.ForceGiveDefaultWeapon"); }

    void ForceGiveDiscoveryZone(int ZoneId, bool bDontNotifyClient) { NativeCall<void, int, bool>(this, "AShooterCharacter.ForceGiveDiscoveryZone", ZoneId, bDontNotifyClient); }

    void ForceGiveDiscoveryZoneByName(FString ManualZoneName) { NativeCall<void, FString>(this, "AShooterCharacter.ForceGiveDiscoveryZoneByName", ManualZoneName); }

    void ForceGiveGlobalDiscoveryZoneByID(int ZoneId, bool bDontNotifyClient) { NativeCall<void, int, bool>(this, "AShooterCharacter.ForceGiveGlobalDiscoveryZoneByID", ZoneId, bDontNotifyClient); }

    void ForceSleep() { NativeCall<void>(this, "AShooterCharacter.ForceSleep"); }

    void GameStateHandleEvent_Implementation(FName NameParam, FVector VecParam) { NativeCall<void, FName, FVector>(this, "AShooterCharacter.GameStateHandleEvent_Implementation", NameParam, VecParam); }

    USceneComponent* GetActorSoundAttachmentComponentOverride(USceneComponent* ForComponent) { return NativeCall<USceneComponent*, USceneComponent*>(this, "AShooterCharacter.GetActorSoundAttachmentComponentOverride", ForComponent); }

    float GetActualTargetingFOV(float DefaultTargetingFOV) { return NativeCall<float, float>(this, "AShooterCharacter.GetActualTargetingFOV", DefaultTargetingFOV); }

    UAnimSequence* GetAdditiveStandingAnim(float* OutBlendInTime, float* OutBlendOutTime) { return NativeCall<UAnimSequence*, float*, float*>(this, "AShooterCharacter.GetAdditiveStandingAnim", OutBlendInTime, OutBlendOutTime); }

    bool GetAdditiveStandingAnimNonAdditive() { return NativeCall<bool>(this, "AShooterCharacter.GetAdditiveStandingAnimNonAdditive"); }

    float GetAge() { return NativeCall<float>(this, "AShooterCharacter.GetAge"); }

    int GetAgeYears() { return NativeCall<int>(this, "AShooterCharacter.GetAgeYears"); }

    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); }

    UAnimSequence* GetAlternateStandingAnim(float* OutBlendInTime, float* OutBlendOutTime) { return NativeCall<UAnimSequence*, float*, float*>(this, "AShooterCharacter.GetAlternateStandingAnim", OutBlendInTime, OutBlendOutTime); }

    APrimalStructureExplosive* GetAttachedExplosive() { return NativeCall<APrimalStructureExplosive*>(this, "AShooterCharacter.GetAttachedExplosive"); }

    float GetBaseTargetingDesire(ITargetableInterface* Attacker) { return NativeCall<float, ITargetableInterface*>(this, "AShooterCharacter.GetBaseTargetingDesire", Attacker); }

    APrimalDinoCharacter* GetBasedOnDino() { return NativeCall<APrimalDinoCharacter*>(this, "AShooterCharacter.GetBasedOnDino"); }

    bool GetBlockingShieldOffsets(FVector* OutBlockingShieldFPVTranslation, FRotator* OutBlockingShieldFPVRotation) { return NativeCall<bool, FVector*, FRotator*>(this, "AShooterCharacter.GetBlockingShieldOffsets", OutBlockingShieldFPVTranslation, OutBlockingShieldFPVRotation); }

    float GetCarryingSocketYaw(bool RefreshBones) { return NativeCall<float, bool>(this, "AShooterCharacter.GetCarryingSocketYaw", RefreshBones); }

    float GetCharacterAdditionalHyperthermiaInsulationValue() { return NativeCall<float>(this, "AShooterCharacter.GetCharacterAdditionalHyperthermiaInsulationValue"); }

    float GetCharacterAdditionalHypothermiaInsulationValue() { return NativeCall<float>(this, "AShooterCharacter.GetCharacterAdditionalHypothermiaInsulationValue"); }

    float GetCharacterAdditionalInsulationValueFromStructure(UWorld* theWorld, FVector* actorLoc, EPrimalItemStat::Type TypeInsulation) { return NativeCall<float, UWorld*, FVector*, EPrimalItemStat::Type>(this, "AShooterCharacter.GetCharacterAdditionalInsulationValueFromStructure", theWorld, actorLoc, TypeInsulation); }

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

    UAnimSequence* GetDinoRidingAnimation() { return NativeCall<UAnimSequence*>(this, "AShooterCharacter.GetDinoRidingAnimation"); }

    UAnimSequence* GetDinoRidingMoveAnimation() { return NativeCall<UAnimSequence*>(this, "AShooterCharacter.GetDinoRidingMoveAnimation"); }

    FLinearColor* GetFacialHairColor(FLinearColor* result) { return NativeCall<FLinearColor*, FLinearColor*>(this, "AShooterCharacter.GetFacialHairColor", result); }

    int GetFacialHairIndex() { return NativeCall<int>(this, "AShooterCharacter.GetFacialHairIndex"); }

    float GetFacialHairMorphTargetValue() { return NativeCall<float>(this, "AShooterCharacter.GetFacialHairMorphTargetValue"); }

    FLinearColor* GetHeadHairColor(FLinearColor* result) { return NativeCall<FLinearColor*, FLinearColor*>(this, "AShooterCharacter.GetHeadHairColor", result); }

    int GetHeadHairIndex() { return NativeCall<int>(this, "AShooterCharacter.GetHeadHairIndex"); }

    float GetHeadHairMorphTargetValue() { return NativeCall<float>(this, "AShooterCharacter.GetHeadHairMorphTargetValue"); }

    float GetInsulationFromItem(FHitResult* HitOut, EPrimalItemStat::Type TypeInsulation) { return NativeCall<float, FHitResult*, EPrimalItemStat::Type>(this, "AShooterCharacter.GetInsulationFromItem", HitOut, TypeInsulation); }

    FTransform* GetLadderComponentToWorld(FTransform* result) { return NativeCall<FTransform*, FTransform*>(this, "AShooterCharacter.GetLadderComponentToWorld", result); }

    long double GetLastFeatUsedTime(TSubclassOf<APrimalBuff> FeatClass) { return NativeCall<long double, TSubclassOf<APrimalBuff>>(this, "AShooterCharacter.GetLastFeatUsedTime", FeatClass); }

    FVector* GetLastSweepLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "AShooterCharacter.GetLastSweepLocation", result); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "AShooterCharacter.GetLifetimeReplicatedProps", OutLifetimeProps); }

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

    float GetMaxCursorHUDDistance(AShooterPlayerController* PC) { return NativeCall<float, AShooterPlayerController*>(this, "AShooterCharacter.GetMaxCursorHUDDistance", PC); }

    float GetMaxGrapplePullMass() { return NativeCall<float>(this, "AShooterCharacter.GetMaxGrapplePullMass"); }

    float GetMaxSpeedModifier() { return NativeCall<float>(this, "AShooterCharacter.GetMaxSpeedModifier"); }

    UPrimalPlayerData* GetMyPlayerData() { return NativeCall<UPrimalPlayerData*>(this, "AShooterCharacter.GetMyPlayerData"); }

    int GetNextWeaponItemID(bool bPrimary) { return NativeCall<int, bool>(this, "AShooterCharacter.GetNextWeaponItemID", bPrimary); }

    APrimalDinoCharacter* GetRidingDino() { return NativeCall<APrimalDinoCharacter*>(this, "AShooterCharacter.GetRidingDino"); }

    UAnimSequence* GetOverridenAnimSequence(UAnimSequence* AnimSeq) { return NativeCall<UAnimSequence*, UAnimSequence*>(this, "AShooterCharacter.GetOverridenAnimSequence", AnimSeq); }

    UAnimMontage* GetOverridenMontage(UAnimMontage* AnimMontage) { return NativeCall<UAnimMontage*, UAnimMontage*>(this, "AShooterCharacter.GetOverridenMontage", AnimMontage); }

    FRotator* GetPassengerAttachedRotation(FRotator* result) { return NativeCall<FRotator*, FRotator*>(this, "AShooterCharacter.GetPassengerAttachedRotation", result); }

    FVector* GetPawnViewLocation(FVector* result, bool bAllTransforms) { return NativeCall<FVector*, FVector*, bool>(this, "AShooterCharacter.GetPawnViewLocation", result, bAllTransforms); }

    float GetPercentageOfFacialHairGrowth() { return NativeCall<float>(this, "AShooterCharacter.GetPercentageOfFacialHairGrowth"); }

    float GetPercentageOfHeadHairGrowth() { return NativeCall<float>(this, "AShooterCharacter.GetPercentageOfHeadHairGrowth"); }

    UPrimalPlayerData* GetPlayerData() { return NativeCall<UPrimalPlayerData*>(this, "AShooterCharacter.GetPlayerData"); }

    float GetRecoilMultiplier() { return NativeCall<float>(this, "AShooterCharacter.GetRecoilMultiplier"); }

    float GetRidingDinoAnimSpeedRatio() { return NativeCall<float>(this, "AShooterCharacter.GetRidingDinoAnimSpeedRatio"); }

    float GetRunningSpeedModifier(bool bIsForDefaultSpeed) { return NativeCall<float, bool>(this, "AShooterCharacter.GetRunningSpeedModifier", bIsForDefaultSpeed); }

    AActor* GetSecondaryMountedActor() { return NativeCall<AActor*>(this, "AShooterCharacter.GetSecondaryMountedActor"); }

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

    AShooterPlayerController* GetSpawnedForController() { return NativeCall<AShooterPlayerController*>(this, "AShooterCharacter.GetSpawnedForController"); }

    float GetTargetingDesirability(ITargetableInterface* Attacker) { return NativeCall<float, ITargetableInterface*>(this, "AShooterCharacter.GetTargetingDesirability", Attacker); }

    float GetTargetingSpeedModifier() { return NativeCall<float>(this, "AShooterCharacter.GetTargetingSpeedModifier"); }

    unsigned int GetUniqueNetIdTypeHash() { return NativeCall<unsigned int>(this, "AShooterCharacter.GetUniqueNetIdTypeHash"); }

    AShooterWeapon* GetWeapon() { return NativeCall<AShooterWeapon*>(this, "AShooterCharacter.GetWeapon"); }

    void GiveMapWeapon(unsigned int typeIndex) { NativeCall<void, unsigned int>(this, "AShooterCharacter.GiveMapWeapon", typeIndex); }

    void HideWeapon() { NativeCall<void>(this, "AShooterCharacter.HideWeapon"); }

    void InitiateTrade_Implementation(unsigned __int64 OtherPlayerID, bool bAcceptingTrade) { NativeCall<void, unsigned __int64, bool>(this, "AShooterCharacter.InitiateTrade_Implementation", OtherPlayerID, bAcceptingTrade); }

    void InviteToAlliance(int RequestingTeam, unsigned int AllianceID, FString AllianceName, FString InviteeName) { NativeCall<void, int, unsigned int, FString, FString>(this, "AShooterCharacter.InviteToAlliance", RequestingTeam, AllianceID, AllianceName, InviteeName); }

    bool IsAwaitingSeamlessTravelController() { return NativeCall<bool>(this, "AShooterCharacter.IsAwaitingSeamlessTravelController"); }

    bool IsCharacterHardAttached(bool bIgnoreRiding, bool bIgnoreCarried) { return NativeCall<bool, bool, bool>(this, "AShooterCharacter.IsCharacterHardAttached", bIgnoreRiding, bIgnoreCarried); }

    bool IsCrafting() { return NativeCall<bool>(this, "AShooterCharacter.IsCrafting"); }

    bool IsCurrentPassengerLimitCameraYaw() { return NativeCall<bool>(this, "AShooterCharacter.IsCurrentPassengerLimitCameraYaw"); }

    bool IsFemale() { return NativeCall<bool>(this, "AShooterCharacter.IsFemale"); }

    bool IsFirstPerson() { return NativeCall<bool>(this, "AShooterCharacter.IsFirstPerson"); }

    bool IsGameInputAllowed() { return NativeCall<bool>(this, "AShooterCharacter.IsGameInputAllowed"); }

    bool IsGrapplingHardAttached(bool bHardAttachedOnlyIfImpacted) { return NativeCall<bool, bool>(this, "AShooterCharacter.IsGrapplingHardAttached", bHardAttachedOnlyIfImpacted); }

    bool IsInCombat() { return NativeCall<bool>(this, "AShooterCharacter.IsInCombat"); }

    static bool IsIndoorsAtLoc(UWorld* theWorld, FVector* actorLoc) { return NativeCall<bool, UWorld*, FVector*>(nullptr, "AShooterCharacter.IsIndoorsAtLoc", theWorld, actorLoc); }

    bool IsNearTopOfLadder() { return NativeCall<bool>(this, "AShooterCharacter.IsNearTopOfLadder"); }

    bool IsOutside() { return NativeCall<bool>(this, "AShooterCharacter.IsOutside"); }

    bool IsPlayingUpperBodyCallAnimation_Implementation() { return NativeCall<bool>(this, "AShooterCharacter.IsPlayingUpperBodyCallAnimation_Implementation"); }

    bool IsProneOrSitting(bool bIgnoreLockedToSeat) { return NativeCall<bool, bool>(this, "AShooterCharacter.IsProneOrSitting", bIgnoreLockedToSeat); }

    bool IsRunning(bool bIncludeFalling, bool bIncludeRunTurning) { return NativeCall<bool, bool, bool>(this, "AShooterCharacter.IsRunning", bIncludeFalling, bIncludeRunTurning); }

    bool IsSubmerged(bool bDontCheckSwimming, bool bUseHalfThreshold, bool bForceCheck, bool bFromVolumeChange) { return NativeCall<bool, bool, bool, bool, bool>(this, "AShooterCharacter.IsSubmerged", bDontCheckSwimming, bUseHalfThreshold, bForceCheck, bFromVolumeChange); }

    bool IsUsingClimbingPick() { return NativeCall<bool>(this, "AShooterCharacter.IsUsingClimbingPick"); }

    bool IsValidForStatusRecovery() { return NativeCall<bool>(this, "AShooterCharacter.IsValidForStatusRecovery"); }

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

    bool IsWatered() { return NativeCall<bool>(this, "AShooterCharacter.IsWatered"); }

    void LaunchMountedDino() { NativeCall<void>(this, "AShooterCharacter.LaunchMountedDino"); }

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

    void LocalPossessedBy(APlayerController* ByController) { NativeCall<void, APlayerController*>(this, "AShooterCharacter.LocalPossessedBy", ByController); }

    void LocalStartCaptainOrder(int OrderIndex) { NativeCall<void, int>(this, "AShooterCharacter.LocalStartCaptainOrder", OrderIndex); }

    void LocalStopCaptainOrder(int OrderIndex) { NativeCall<void, int>(this, "AShooterCharacter.LocalStopCaptainOrder", OrderIndex); }

    float ModifyAirControl(float AirControlIn) { return NativeCall<float, float>(this, "AShooterCharacter.ModifyAirControl", AirControlIn); }

    void ModifyFirstPersonCameraLocation(FVector* Loc, float DeltaTime) { NativeCall<void, FVector*, float>(this, "AShooterCharacter.ModifyFirstPersonCameraLocation", Loc, DeltaTime); }

    bool MoveToInnerLoop(AActor* TargetToMove, FVector MoveToLoc, AActor* TargetActor) { return NativeCall<bool, AActor*, FVector, AActor*>(this, "AShooterCharacter.MoveToInnerLoop", TargetToMove, MoveToLoc, TargetActor); }

    void MultiClearTradeID_Implementation() { NativeCall<void>(this, "AShooterCharacter.MultiClearTradeID_Implementation"); }

    void NetSetBodyFatPercent_Implementation(float thePercent) { NativeCall<void, float>(this, "AShooterCharacter.NetSetBodyFatPercent_Implementation", thePercent); }

    void NetSetFacialHairPercent_Implementation(float thePercent, int newFacialHairIndex) { NativeCall<void, float, int>(this, "AShooterCharacter.NetSetFacialHairPercent_Implementation", thePercent, newFacialHairIndex); }

    void NetSetHeadHairPercent_Implementation(float thePercent, int newHeadHairIndex) { NativeCall<void, float, int>(this, "AShooterCharacter.NetSetHeadHairPercent_Implementation", thePercent, newHeadHairIndex); }

    void NetSetMaxWetness_Implementation() { NativeCall<void>(this, "AShooterCharacter.NetSetMaxWetness_Implementation"); }

    void NetSetOverrideFacialHairColor_Implementation(FLinearColor HairColor) { NativeCall<void, FLinearColor>(this, "AShooterCharacter.NetSetOverrideFacialHairColor_Implementation", HairColor); }

    void NetSetOverrideHeadHairColor_Implementation(FLinearColor HairColor) { NativeCall<void, FLinearColor>(this, "AShooterCharacter.NetSetOverrideHeadHairColor_Implementation", HairColor); }

    void NetSimulatedForceUpdateAimedActors_Implementation(float OverrideMaxDistance) { NativeCall<void, float>(this, "AShooterCharacter.NetSimulatedForceUpdateAimedActors_Implementation", OverrideMaxDistance); }

    void NotifyBumpedPawn(APawn* BumpedPawn) { NativeCall<void, APawn*>(this, "AShooterCharacter.NotifyBumpedPawn", BumpedPawn); }

    void NotifyEquippedItems() { NativeCall<void>(this, "AShooterCharacter.NotifyEquippedItems"); }

    void NotifySwitchedCameraPerspective(bool bToFirstPerson) { NativeCall<void, bool>(this, "AShooterCharacter.NotifySwitchedCameraPerspective", bToFirstPerson); }

    void OnBeginDrag_Implementation(APrimalCharacter* Dragged, int BoneIndex, bool bWithGrapHook) { NativeCall<void, APrimalCharacter*, int, bool>(this, "AShooterCharacter.OnBeginDrag_Implementation", Dragged, BoneIndex, bWithGrapHook); }

    void OnCameraUpdate(FVector* CameraLocation, FRotator* CameraRotation) { NativeCall<void, FVector*, FRotator*>(this, "AShooterCharacter.OnCameraUpdate", CameraLocation, CameraRotation); }

    void OnEndCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust) { NativeCall<void, float, float>(this, "AShooterCharacter.OnEndCrouch", HalfHeightAdjust, ScaledHalfHeightAdjust); }

    void OnEndDrag_Implementation() { NativeCall<void>(this, "AShooterCharacter.OnEndDrag_Implementation"); }

    void OnEnteredDiscoveryZone(int ZoneId) { NativeCall<void, int>(this, "AShooterCharacter.OnEnteredDiscoveryZone", ZoneId); }

    void OnExitedDiscoveryZone(int ZoneId) { NativeCall<void, int>(this, "AShooterCharacter.OnExitedDiscoveryZone", ZoneId); }

    void OnFailedJumped() { NativeCall<void>(this, "AShooterCharacter.OnFailedJumped"); }

    void OnMovementModeChanged(EMovementMode PrevMovementMode, char PreviousCustomMode) { NativeCall<void, EMovementMode, char>(this, "AShooterCharacter.OnMovementModeChanged", PrevMovementMode, PreviousCustomMode); }

    void OnPressCrouch() { NativeCall<void>(this, "AShooterCharacter.OnPressCrouch"); }

    void OnPressCrouchProneToggle() { NativeCall<void>(this, "AShooterCharacter.OnPressCrouchProneToggle"); }

    void OnPressProne() { NativeCall<void>(this, "AShooterCharacter.OnPressProne"); }

    void OnPressReload() { NativeCall<void>(this, "AShooterCharacter.OnPressReload"); }

    void OnPressReloadAll() { NativeCall<void>(this, "AShooterCharacter.OnPressReloadAll"); }

    void OnPrimalCharacterSleeped() { NativeCall<void>(this, "AShooterCharacter.OnPrimalCharacterSleeped"); }

    void OnReleaseCrouchProneToggle() { NativeCall<void>(this, "AShooterCharacter.OnReleaseCrouchProneToggle"); }

    void OnReload() { NativeCall<void>(this, "AShooterCharacter.OnReload"); }

    void OnRep_BonePresets() { NativeCall<void>(this, "AShooterCharacter.OnRep_BonePresets"); }

    void OnRep_CurrentVoiceModeAsUInt32() { NativeCall<void>(this, "AShooterCharacter.OnRep_CurrentVoiceModeAsUInt32"); }

    void OnRep_CurrentWeapon(AShooterWeapon* LastWeapon) { NativeCall<void, AShooterWeapon*>(this, "AShooterCharacter.OnRep_CurrentWeapon", LastWeapon); }

    void OnRep_HatHidden() { NativeCall<void>(this, "AShooterCharacter.OnRep_HatHidden"); }

    void OnRep_LadderAttachment() { NativeCall<void>(this, "AShooterCharacter.OnRep_LadderAttachment"); }

    void OnRep_PlayerBadgeGroup() { NativeCall<void>(this, "AShooterCharacter.OnRep_PlayerBadgeGroup"); }

    void OnRep_TattooPaintingComponent() { NativeCall<void>(this, "AShooterCharacter.OnRep_TattooPaintingComponent"); }

    void OnRep_VivoxUsername() { NativeCall<void>(this, "AShooterCharacter.OnRep_VivoxUsername"); }

    void OnSpawnPointsRecieved() { NativeCall<void>(this, "AShooterCharacter.OnSpawnPointsRecieved"); }

    void OnStartAltFire() { NativeCall<void>(this, "AShooterCharacter.OnStartAltFire"); }

    void OnStartCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust) { NativeCall<void, float, float>(this, "AShooterCharacter.OnStartCrouch", HalfHeightAdjust, ScaledHalfHeightAdjust); }

    void OnStartFire(bool bFromGamepadRight, int weaponAttackIndex, bool bDoLeftSide, bool bOverrideCurrentAttack) { NativeCall<void, bool, int, bool, bool>(this, "AShooterCharacter.OnStartFire", bFromGamepadRight, weaponAttackIndex, bDoLeftSide, bOverrideCurrentAttack); }

    void OnStartRunning() { NativeCall<void>(this, "AShooterCharacter.OnStartRunning"); }

    void OnStartTargeting(bool bFromGamepadLeft) { NativeCall<void, bool>(this, "AShooterCharacter.OnStartTargeting", bFromGamepadLeft); }

    void OnStopAltFire() { NativeCall<void>(this, "AShooterCharacter.OnStopAltFire"); }

    void OnStopFire(bool bFromGamepadRight, int weaponAttackIndex) { NativeCall<void, bool, int>(this, "AShooterCharacter.OnStopFire", bFromGamepadRight, weaponAttackIndex); }

    void OnStopTargeting(bool bFromGamepadLeft) { NativeCall<void, bool>(this, "AShooterCharacter.OnStopTargeting", bFromGamepadLeft); }

    void OnVoiceTalkingStateChanged(bool talking, bool IsUsingSuperRange) { NativeCall<void, bool, bool>(this, "AShooterCharacter.OnVoiceTalkingStateChanged", talking, IsUsingSuperRange); }

    void OrbitCamOn() { NativeCall<void>(this, "AShooterCharacter.OrbitCamOn"); }

    void OrbitCamToggle() { NativeCall<void>(this, "AShooterCharacter.OrbitCamToggle"); }

    FVector* OverrideNewFallVelocity(FVector* result, FVector* InitialVelocity, FVector* Gravity, float DeltaTime) { return NativeCall<FVector*, FVector*, FVector*, FVector*, float>(this, "AShooterCharacter.OverrideNewFallVelocity", result, InitialVelocity, Gravity, DeltaTime); }

    FVector* OverrideSwimmingVelocity(FVector* result, FVector* InitialVelocity, FVector* Gravity, const float* FluidFriction, const float* NetBuoyancy, float DeltaTime) { return NativeCall<FVector*, FVector*, FVector*, FVector*, const float*, const float*, float>(this, "AShooterCharacter.OverrideSwimmingVelocity", result, InitialVelocity, Gravity, FluidFriction, NetBuoyancy, DeltaTime); }

    FVector* OverrideWalkingVelocity(FVector* result, FVector* InitialVelocity, const float* Friction, float DeltaTime) { return NativeCall<FVector*, FVector*, FVector*, const float*, float>(this, "AShooterCharacter.OverrideWalkingVelocity", result, InitialVelocity, Friction, DeltaTime); }

    void PlayDrinkingAnimation() { NativeCall<void>(this, "AShooterCharacter.PlayDrinkingAnimation"); }

    void PlayDying(float KillingDamage, FDamageEvent* DamageEvent, APawn* InstigatingPawn, AActor* DamageCauser) { NativeCall<void, float, FDamageEvent*, APawn*, AActor*>(this, "AShooterCharacter.PlayDying", KillingDamage, DamageEvent, InstigatingPawn, DamageCauser); }

    void PlayEmoteAnimation_Implementation(char EmoteIndex) { NativeCall<void, char>(this, "AShooterCharacter.PlayEmoteAnimation_Implementation", EmoteIndex); }

    void PlayJumpAnim() { NativeCall<void>(this, "AShooterCharacter.PlayJumpAnim"); }

    void PlayLandedAnim() { NativeCall<void>(this, "AShooterCharacter.PlayLandedAnim"); }

    void PlaySpawnIntro() { NativeCall<void>(this, "AShooterCharacter.PlaySpawnIntro"); }

    void PlayTalkingAnimation() { NativeCall<void>(this, "AShooterCharacter.PlayTalkingAnimation"); }

    void Poop(bool bForcePoop) { NativeCall<void, bool>(this, "AShooterCharacter.Poop", bForcePoop); }

    void PossessedBy(AController* InController) { NativeCall<void, AController*>(this, "AShooterCharacter.PossessedBy", InController); }

    void PostInitializeComponents() { NativeCall<void>(this, "AShooterCharacter.PostInitializeComponents"); }

    void PreApplyAccumulatedForces(float DeltaSeconds, FVector* PendingImpulseToApply, FVector* PendingForceToApply) { NativeCall<void, float, FVector*, FVector*>(this, "AShooterCharacter.PreApplyAccumulatedForces", DeltaSeconds, PendingImpulseToApply, PendingForceToApply); }

    void PreInitializeComponents() { NativeCall<void>(this, "AShooterCharacter.PreInitializeComponents"); }

    bool PreventMovementMode(EMovementMode NewMovementMode, char NewCustomMode) { return NativeCall<bool, EMovementMode, char>(this, "AShooterCharacter.PreventMovementMode", NewMovementMode, NewCustomMode); }

    void RecalculateBaseEyeHeight() { NativeCall<void>(this, "AShooterCharacter.RecalculateBaseEyeHeight"); }

    void RefreshDefaultAttachments(AActor* UseOtherActor) { NativeCall<void, AActor*>(this, "AShooterCharacter.RefreshDefaultAttachments", UseOtherActor); }

    void RefreshTribeName() { NativeCall<void>(this, "AShooterCharacter.RefreshTribeName"); }

    void RegisterActorTickFunctions(bool bRegister, bool bSaveAndRestoreTickState) { NativeCall<void, bool, bool>(this, "AShooterCharacter.RegisterActorTickFunctions", bRegister, bSaveAndRestoreTickState); }

    void ReleaseSeatingStructureHandIK() { NativeCall<void>(this, "AShooterCharacter.ReleaseSeatingStructureHandIK"); }

    void RemoveAttachments() { NativeCall<void>(this, "AShooterCharacter.RemoveAttachments"); }

    void RenamePlayer_Implementation(FString* NewName) { NativeCall<void, FString*>(this, "AShooterCharacter.RenamePlayer_Implementation", NewName); }

    void ResetBase() { NativeCall<void>(this, "AShooterCharacter.ResetBase"); }

    void ServerCallAggressive_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerCallAggressive_Implementation"); }

    void ServerCallAttackTarget_Implementation(AActor* TheTarget) { NativeCall<void, AActor*>(this, "AShooterCharacter.ServerCallAttackTarget_Implementation", TheTarget); }

    void ServerCallFollowDistanceCycleOne_Implementation(APrimalDinoCharacter* ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterCharacter.ServerCallFollowDistanceCycleOne_Implementation", ForDinoChar); }

    void ServerCallFollowOne_Implementation(APrimalDinoCharacter* ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterCharacter.ServerCallFollowOne_Implementation", ForDinoChar); }

    void ServerCallFollow_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerCallFollow_Implementation"); }

    void ServerCallMoveToRaft_Implementation(FVector MoveToRelLoc, APrimalRaft* TargetRaft, int ToDeckIndex) { NativeCall<void, FVector, APrimalRaft*, int>(this, "AShooterCharacter.ServerCallMoveToRaft_Implementation", MoveToRelLoc, TargetRaft, ToDeckIndex); }

    void ServerCallMoveTo_Implementation(FVector MoveToLoc, AActor* TargetActor) { NativeCall<void, FVector, AActor*>(this, "AShooterCharacter.ServerCallMoveTo_Implementation", MoveToLoc, TargetActor); }

    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 ServerCallStayOne_Implementation(APrimalDinoCharacter* ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterCharacter.ServerCallStayOne_Implementation", ForDinoChar); }

    void ServerCallStay_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerCallStay_Implementation"); }

    void ServerCheckDrinkingWater_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerCheckDrinkingWater_Implementation"); }

    void ServerClearSwitchingWeapon_Implementation(bool bOnlyIfDefaultWeapon, bool bClientRequestNextWeaponID) { NativeCall<void, bool, bool>(this, "AShooterCharacter.ServerClearSwitchingWeapon_Implementation", bOnlyIfDefaultWeapon, bClientRequestNextWeaponID); }

    void ServerDetachGrapHookCable_Implementation(bool bDoUpwardsJump, float UpwardsJumpYaw) { NativeCall<void, bool, float>(this, "AShooterCharacter.ServerDetachGrapHookCable_Implementation", bDoUpwardsJump, UpwardsJumpYaw); }

    void ServerFireBallistaProjectile_Implementation(FVector Origin, FVector_NetQuantizeNormal ShootDir) { NativeCall<void, FVector, FVector_NetQuantizeNormal>(this, "AShooterCharacter.ServerFireBallistaProjectile_Implementation", Origin, ShootDir); }

    void ServerForceUpdatedAimedActors(float OverrideMaxDistance, bool bReplicateToSimulatedClients) { NativeCall<void, float, bool>(this, "AShooterCharacter.ServerForceUpdatedAimedActors", OverrideMaxDistance, bReplicateToSimulatedClients); }

    void ServerGiveDefaultWeapon_Implementation(bool bOnlyGiveDefaultWeapon) { NativeCall<void, bool>(this, "AShooterCharacter.ServerGiveDefaultWeapon_Implementation", bOnlyGiveDefaultWeapon); }

    void ServerLaunchMountedDino_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerLaunchMountedDino_Implementation"); }

    void ServerNetEndClimbingLadder_Implementation(bool bIsClimbOver, FVector ClimbOverLoc, float RightDir) { NativeCall<void, bool, FVector, float>(this, "AShooterCharacter.ServerNetEndClimbingLadder_Implementation", bIsClimbOver, ClimbOverLoc, RightDir); }

    void ServerPrepareForSeamlessTravel_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerPrepareForSeamlessTravel_Implementation"); }

    void ServerRequestCaptainOrder_Implementation(int OrderIndex, TArray<int>* GroupsIndex) { NativeCall<void, int, TArray<int>*>(this, "AShooterCharacter.ServerRequestCaptainOrder_Implementation", OrderIndex, GroupsIndex); }

    void ServerRequestFeatCooldowns_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerRequestFeatCooldowns_Implementation"); }

    void ServerRequestStopCaptainOrder_Implementation(int OrderIndex, TArray<int>* GroupsIndex, TArray<int>* StationsToFire, AActor* OrderTarget) { NativeCall<void, int, TArray<int>*, TArray<int>*, AActor*>(this, "AShooterCharacter.ServerRequestStopCaptainOrder_Implementation", OrderIndex, GroupsIndex, StationsToFire, OrderTarget); }

    void ServerResyncNameToClients() { NativeCall<void>(this, "AShooterCharacter.ServerResyncNameToClients"); }

    void ServerSailRiderSetRotationInput_Implementation(float Val) { NativeCall<void, float>(this, "AShooterCharacter.ServerSailRiderSetRotationInput_Implementation", Val); }

    void ServerSailRiderSetThrottleInput_Implementation(float Val) { NativeCall<void, float>(this, "AShooterCharacter.ServerSailRiderSetThrottleInput_Implementation", Val); }

    void ServerSailRiderSetThrottleValue_Implementation(float Val) { NativeCall<void, float>(this, "AShooterCharacter.ServerSailRiderSetThrottleValue_Implementation", Val); }

    void ServerSetBallistaNewRotation_Implementation(float Pitch, float Yaw) { NativeCall<void, float, float>(this, "AShooterCharacter.ServerSetBallistaNewRotation_Implementation", Pitch, Yaw); }

    void ServerSetCaptainsOrderToLastPassive_Implementation(ECaptainOrder::Type OrderIndexToCancelFrom, TArray<int>* GroupsIndex) { NativeCall<void, ECaptainOrder::Type, TArray<int>*>(this, "AShooterCharacter.ServerSetCaptainsOrderToLastPassive_Implementation", OrderIndexToCancelFrom, GroupsIndex); }

    void ServerSetIsVoiceActive_Implementation(bool IsActive) { NativeCall<void, bool>(this, "AShooterCharacter.ServerSetIsVoiceActive_Implementation", IsActive); }

    void ServerSetViewingInventory_Implementation(bool bIsViewing) { NativeCall<void, bool>(this, "AShooterCharacter.ServerSetViewingInventory_Implementation", bIsViewing); }

    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); }

    void ServerStopFireBallista_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerStopFireBallista_Implementation"); }

    void ServerSwitchMap_Implementation(unsigned int typeIndex) { NativeCall<void, unsigned int>(this, "AShooterCharacter.ServerSwitchMap_Implementation", typeIndex); }

    void ServerTellNPCCaptainSailFacingDirection_Implementation(float YawDir) { NativeCall<void, float>(this, "AShooterCharacter.ServerTellNPCCaptainSailFacingDirection_Implementation", YawDir); }

    void ServerTryToCycleBallistaAmmoType_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerTryToCycleBallistaAmmoType_Implementation"); }

    void ServerTryToReloadBallista_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerTryToReloadBallista_Implementation"); }

    void ServerUpdateCurrentVoiceModeAsUInt32_Implementation(unsigned int NewValue) { NativeCall<void, unsigned int>(this, "AShooterCharacter.ServerUpdateCurrentVoiceModeAsUInt32_Implementation", NewValue); }

    void ServerWhistleCloseSails_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerWhistleCloseSails_Implementation"); }

    void ServerWhistleOpenSails_Implementation() { NativeCall<void>(this, "AShooterCharacter.ServerWhistleOpenSails_Implementation"); }

    void SetActorHiddenInGame(bool bNewHidden) { NativeCall<void, bool>(this, "AShooterCharacter.SetActorHiddenInGame", bNewHidden); }

    void SetCameraMode(bool bFirstperson, bool bIgnoreSettingFirstPersonRiding) { NativeCall<void, bool, bool>(this, "AShooterCharacter.SetCameraMode", bFirstperson, bIgnoreSettingFirstPersonRiding); }

    void SetCarriedPitchYaw_Implementation(float NewCarriedPitch, float NewCarriedYaw) { NativeCall<void, float, float>(this, "AShooterCharacter.SetCarriedPitchYaw_Implementation", NewCarriedPitch, NewCarriedYaw); }

    void SetCarryingDino(APrimalDinoCharacter* aDino) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterCharacter.SetCarryingDino", aDino); }

    void SetCharacterMeshesMaterialScalarParamValue(FName ParamName, float Value) { NativeCall<void, FName, float>(this, "AShooterCharacter.SetCharacterMeshesMaterialScalarParamValue", ParamName, Value); }

    void SetCurrentWeapon(AShooterWeapon* NewWeapon, AShooterWeapon* LastWeapon) { NativeCall<void, AShooterWeapon*, AShooterWeapon*>(this, "AShooterCharacter.SetCurrentWeapon", NewWeapon, LastWeapon); }

    void SetEnableHandIK(bool bLeft, bool bRight, bool bBindForwad) { NativeCall<void, bool, bool, bool>(this, "AShooterCharacter.SetEnableHandIK", bLeft, bRight, bBindForwad); }

    void SetMiniGameReloadCounter(int NewValue) { NativeCall<void, int>(this, "AShooterCharacter.SetMiniGameReloadCounter", NewValue); }

    void SetRidingDino(APrimalDinoCharacter* aDino) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterCharacter.SetRidingDino", aDino); }

    void SetRidingDinoAsPassenger(APrimalDinoCharacter* aDino, FSaddlePassengerSeatDefinition* SeatDefinition) { NativeCall<void, APrimalDinoCharacter*, FSaddlePassengerSeatDefinition*>(this, "AShooterCharacter.SetRidingDinoAsPassenger", aDino, SeatDefinition); }

    void SetSleeping(bool bSleeping, bool bUseRagdollLocationOffset) { NativeCall<void, bool, bool>(this, "AShooterCharacter.SetSleeping", bSleeping, bUseRagdollLocationOffset); }

    bool ShouldIKBeForceDisabled() { return NativeCall<bool>(this, "AShooterCharacter.ShouldIKBeForceDisabled"); }

    bool ShouldOverrideNewFallVelocity() { return NativeCall<bool>(this, "AShooterCharacter.ShouldOverrideNewFallVelocity"); }

    bool ShouldOverrideSwimmingVelocity() { return NativeCall<bool>(this, "AShooterCharacter.ShouldOverrideSwimmingVelocity"); }

    bool ShouldOverrideWalkingVelocity() { return NativeCall<bool>(this, "AShooterCharacter.ShouldOverrideWalkingVelocity"); }

    bool ShouldReplicateRotPitch() { return NativeCall<bool>(this, "AShooterCharacter.ShouldReplicateRotPitch"); }

    bool ShouldStoreSecondaryItemID(UPrimalItem* SecondaryItem) { return NativeCall<bool, UPrimalItem*>(this, "AShooterCharacter.ShouldStoreSecondaryItemID", SecondaryItem); }

    bool ShouldTempDisableMultiFabrik() { return NativeCall<bool>(this, "AShooterCharacter.ShouldTempDisableMultiFabrik"); }

    void ShowDiscoveryExplorerNoteOnDelay(int ExplorerNoteIndex) { NativeCall<void, int>(this, "AShooterCharacter.ShowDiscoveryExplorerNoteOnDelay", ExplorerNoteIndex); }

    void ShowWeapon() { NativeCall<void>(this, "AShooterCharacter.ShowWeapon"); }

    void StartCameraTransition(float Duration) { NativeCall<void, float>(this, "AShooterCharacter.StartCameraTransition", Duration); }

    void StartWeaponSwitch(UPrimalItem* aPrimalItem, bool bDontClearLastWeapon) { NativeCall<void, UPrimalItem*, bool>(this, "AShooterCharacter.StartWeaponSwitch", aPrimalItem, bDontClearLastWeapon); }

    void StasisingCharacter() { NativeCall<void>(this, "AShooterCharacter.StasisingCharacter"); }

    AActor* StructurePlacementUseAlternateOriginActor() { return NativeCall<AActor*>(this, "AShooterCharacter.StructurePlacementUseAlternateOriginActor"); }

    void SwitchMap(unsigned int typeIndex) { NativeCall<void, unsigned int>(this, "AShooterCharacter.SwitchMap", typeIndex); }

    void TakeSeatingStructureHandIK() { NativeCall<void>(this, "AShooterCharacter.TakeSeatingStructureHandIK"); }

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

    bool TeleportTo(FVector* DestLocation, FRotator* DestRotation, bool bIsATest, bool bNoCheck) { return NativeCall<bool, FVector*, FRotator*, bool, bool>(this, "AShooterCharacter.TeleportTo", DestLocation, DestRotation, bIsATest, bNoCheck); }

    void TempDampenInputAcceleration() { NativeCall<void>(this, "AShooterCharacter.TempDampenInputAcceleration"); }

    void Tick(float DeltaSeconds) { NativeCall<void, float>(this, "AShooterCharacter.Tick", DeltaSeconds); }

    void TickUpdateHandIK(float DeltaSeconds) { NativeCall<void, float>(this, "AShooterCharacter.TickUpdateHandIK", DeltaSeconds); }

    void TogglePerspective() { NativeCall<void>(this, "AShooterCharacter.TogglePerspective"); }

    bool TryAccessInventory() { return NativeCall<bool>(this, "AShooterCharacter.TryAccessInventory"); }

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

    void Unstasis() { NativeCall<void>(this, "AShooterCharacter.Unstasis"); }

    void UpdateCarriedLocationAndRotation(float DeltaSeconds) { NativeCall<void, float>(this, "AShooterCharacter.UpdateCarriedLocationAndRotation", DeltaSeconds); }

    void UpdateGrapHook(float DeltaSeconds) { NativeCall<void, float>(this, "AShooterCharacter.UpdateGrapHook", DeltaSeconds); }

    void UpdateHair() { NativeCall<void>(this, "AShooterCharacter.UpdateHair"); }

    void UpdatePawnMeshes(bool bForceThirdPerson, bool bForceFlush) { NativeCall<void, bool, bool>(this, "AShooterCharacter.UpdatePawnMeshes", bForceThirdPerson, bForceFlush); }

    void UpdateSeatingStructureHandIK() { NativeCall<void>(this, "AShooterCharacter.UpdateSeatingStructureHandIK"); }

    void UpdateSwimmingState() { NativeCall<void>(this, "AShooterCharacter.UpdateSwimmingState"); }

    void UpdateTopTribesGroup() { NativeCall<void>(this, "AShooterCharacter.UpdateTopTribesGroup"); }

    void UpdateTransponders() { NativeCall<void>(this, "AShooterCharacter.UpdateTransponders"); }

    void UpdateWeaponHandIK() { NativeCall<void>(this, "AShooterCharacter.UpdateWeaponHandIK"); }

    bool UseAdditiveStandingAnim() { return NativeCall<bool>(this, "AShooterCharacter.UseAdditiveStandingAnim"); }

    bool UseAltAimOffsetAnim() { return NativeCall<bool>(this, "AShooterCharacter.UseAltAimOffsetAnim"); }

    bool UseAlternateStandingAnim() { return NativeCall<bool>(this, "AShooterCharacter.UseAlternateStandingAnim"); }

    bool UseSwimmingTPVAimOffset() { return NativeCall<bool>(this, "AShooterCharacter.UseSwimmingTPVAimOffset"); }

    bool ValidToRestoreForPC(AShooterPlayerController* aPC) { return NativeCall<bool, AShooterPlayerController*>(this, "AShooterCharacter.ValidToRestoreForPC", aPC); }

    void WasPushed(ACharacter* ByOtherCharacter) { NativeCall<void, ACharacter*>(this, "AShooterCharacter.WasPushed", ByOtherCharacter); }

    void ZoomIn() { NativeCall<void>(this, "AShooterCharacter.ZoomIn"); }

    void ZoomOut() { NativeCall<void>(this, "AShooterCharacter.ZoomOut"); }

    void AttachToLadder(USceneComponent* Parent) { NativeCall<void, USceneComponent*>(this, "AShooterCharacter.AttachToLadder", Parent); }

    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 ClientOnDiscoveredZone(int ZoneId, int NewNumZonesDiscovered) { NativeCall<void, int, int>(this, "AShooterCharacter.ClientOnDiscoveredZone", ZoneId, NewNumZonesDiscovered); }

    void ClientOrderedAttackTarget(AActor* attackTarget) { NativeCall<void, AActor*>(this, "AShooterCharacter.ClientOrderedAttackTarget", attackTarget); }

    void ClientOrderedMoveTo(FVector MoveToLoc, AActor* MoveToActorRef) { NativeCall<void, FVector, AActor*>(this, "AShooterCharacter.ClientOrderedMoveTo", MoveToLoc, MoveToActorRef); }

    void ClientOrderedMoveToRaft(FVector MoveToRelLoc, APrimalRaft* MoveToRaftRef, int ToDeckIndex) { NativeCall<void, FVector, APrimalRaft*, int>(this, "AShooterCharacter.ClientOrderedMoveToRaft", MoveToRelLoc, MoveToRaftRef, ToDeckIndex); }

    void ClientPlayHarvestAnim() { NativeCall<void>(this, "AShooterCharacter.ClientPlayHarvestAnim"); }

    void ClientReceiveFeatCooldowns(TArray<FFeatCooldown>* theFeatCooldowns) { NativeCall<void, TArray<FFeatCooldown>*>(this, "AShooterCharacter.ClientReceiveFeatCooldowns", theFeatCooldowns); }

    void ClientReceiveNextWeaponID(FItemNetID theItemID) { NativeCall<void, FItemNetID>(this, "AShooterCharacter.ClientReceiveNextWeaponID", theItemID); }

    void ClientTradeNotification(AShooterCharacter* OtherPlayer) { NativeCall<void, AShooterCharacter*>(this, "AShooterCharacter.ClientTradeNotification", OtherPlayer); }

    void ClientUpdateTranspondersInfo(TArray<FTransponderInfo>* TranspondersInfo, bool bNewData) { NativeCall<void, TArray<FTransponderInfo>*, bool>(this, "AShooterCharacter.ClientUpdateTranspondersInfo", TranspondersInfo, bNewData); }

    void DetachFromLadder(bool bIgnoreOnAutonomousProxy) { NativeCall<void, bool>(this, "AShooterCharacter.DetachFromLadder", bIgnoreOnAutonomousProxy); }

    void DetachGrapHookCable(bool bDoUpwardsJump, float UpwardsJumpYaw) { NativeCall<void, bool, float>(this, "AShooterCharacter.DetachGrapHookCable", bDoUpwardsJump, UpwardsJumpYaw); }

    void GameStateHandleEvent(FName NameParam, FVector VecParam) { NativeCall<void, FName, FVector>(this, "AShooterCharacter.GameStateHandleEvent", NameParam, VecParam); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "AShooterCharacter.GetPrivateStaticClass", Package); }

    void InitiateTrade(unsigned __int64 OtherPlayerID, bool bAcceptingTrade) { NativeCall<void, unsigned __int64, bool>(this, "AShooterCharacter.InitiateTrade", OtherPlayerID, bAcceptingTrade); }

    bool IsPlayingUpperBodyCallAnimation() { return NativeCall<bool>(this, "AShooterCharacter.IsPlayingUpperBodyCallAnimation"); }

    void MultiClearTradeID() { NativeCall<void>(this, "AShooterCharacter.MultiClearTradeID"); }

    void NetSetBodyFatPercent(float thePercent) { NativeCall<void, float>(this, "AShooterCharacter.NetSetBodyFatPercent", thePercent); }

    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 NetSetMaxWetness() { NativeCall<void>(this, "AShooterCharacter.NetSetMaxWetness"); }

    void NetSimulatedForceUpdateAimedActors(float OverrideMaxDistance) { NativeCall<void, float>(this, "AShooterCharacter.NetSimulatedForceUpdateAimedActors", OverrideMaxDistance); }

    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 ServerRequestCaptainOrder(int OrderIndex, TArray<int>* GroupsIndex) { NativeCall<void, int, TArray<int>*>(this, "AShooterCharacter.ServerRequestCaptainOrder", OrderIndex, GroupsIndex); }

    void ServerRequestFeatCooldowns() { NativeCall<void>(this, "AShooterCharacter.ServerRequestFeatCooldowns"); }

    void ServerRequestStopCaptainOrder(int OrderIndex, TArray<int>* GroupsIndex, TArray<int>* StationsToFire, AActor* OrderTarget) { NativeCall<void, int, TArray<int>*, TArray<int>*, AActor*>(this, "AShooterCharacter.ServerRequestStopCaptainOrder", OrderIndex, GroupsIndex, StationsToFire, OrderTarget); }

    void ServerSailRiderSetRotationInput(float Val) { NativeCall<void, float>(this, "AShooterCharacter.ServerSailRiderSetRotationInput", Val); }

    void ServerSailRiderSetThrottleInput(float Val) { NativeCall<void, float>(this, "AShooterCharacter.ServerSailRiderSetThrottleInput", Val); }

    void ServerSailRiderSetThrottleValue(float Val) { NativeCall<void, float>(this, "AShooterCharacter.ServerSailRiderSetThrottleValue", Val); }

    void ServerSetBallistaNewRotation(float Pitch, float Yaw) { NativeCall<void, float, float>(this, "AShooterCharacter.ServerSetBallistaNewRotation", Pitch, Yaw); }

    void ServerSetCaptainsOrderToLastPassive(ECaptainOrder::Type OrderIndexToCancelFrom, TArray<int>* GroupsIndex) { NativeCall<void, ECaptainOrder::Type, TArray<int>*>(this, "AShooterCharacter.ServerSetCaptainsOrderToLastPassive", OrderIndexToCancelFrom, GroupsIndex); }

    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(unsigned int typeIndex) { NativeCall<void, unsigned int>(this, "AShooterCharacter.ServerSwitchMap", typeIndex); }

    void ServerTellNPCCaptainSailFacingDirection(float YawDir) { NativeCall<void, float>(this, "AShooterCharacter.ServerTellNPCCaptainSailFacingDirection", YawDir); }

    void ServerTryToCycleBallistaAmmoType() { NativeCall<void>(this, "AShooterCharacter.ServerTryToCycleBallistaAmmoType"); }

    void ServerTryToReloadBallista() { NativeCall<void>(this, "AShooterCharacter.ServerTryToReloadBallista"); }

    void ServerUpdateCurrentVoiceModeAsUInt32(unsigned int NewValue) { NativeCall<void, unsigned int>(this, "AShooterCharacter.ServerUpdateCurrentVoiceModeAsUInt32", NewValue); }

    void ServerWhistleCloseSails() { NativeCall<void>(this, "AShooterCharacter.ServerWhistleCloseSails"); }

    void ServerWhistleOpenSails() { NativeCall<void>(this, "AShooterCharacter.ServerWhistleOpenSails"); }

    void SetCarriedPitchYaw(float NewCarriedPitch, float NewCarriedYaw) { NativeCall<void, float, float>(this, "AShooterCharacter.SetCarriedPitchYaw", NewCarriedPitch, NewCarriedYaw); }

    static void StaticRegisterNativesAShooterCharacter() { NativeCall<void>(nullptr, "AShooterCharacter.StaticRegisterNativesAShooterCharacter"); }

    AShooterPlayerController* GetShooterPC() { return NativeCall<AShooterPlayerController*>(this, "AShooterCharacter.GetShooterPC"); }

};


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"); }

    TArray<unsigned int>& PerMapExplorerNoteUnlocksField() { return *GetNativePointerField<TArray<unsigned int>*>(this, "FPrimalPersistentCharacterStatsStruct.PerMapExplorerNoteUnlocks"); }

    TArray<FName>& EmoteUnlocksField() { return *GetNativePointerField<TArray<FName>*>(this, "FPrimalPersistentCharacterStatsStruct.EmoteUnlocks"); }

    TArray<FName>& FeatUnlocksField() { return *GetNativePointerField<TArray<FName>*>(this, "FPrimalPersistentCharacterStatsStruct.FeatUnlocks"); }

    TArray<FDefaultItemEntry>& ExtraDefaultItemsField() { return *GetNativePointerField<TArray<FDefaultItemEntry>*>(this, "FPrimalPersistentCharacterStatsStruct.ExtraDefaultItems"); }

    TArray<TSubclassOf<UPrimalEngramEntry>>& PlayerState_UnlockedSkillsField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalEngramEntry>>*>(this, "FPrimalPersistentCharacterStatsStruct.PlayerState_UnlockedSkills"); }

    FieldArray<char, 16> 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<TSubclassOf<APrimalBuff>, 10> PlayerState_FeatHotkeysField() { return { this, "FPrimalPersistentCharacterStatsStruct.PlayerState_FeatHotkeys" }; }

    FieldArray<FDinoOrderGroup, 10> DinoOrderGroupsField() { return { this, "FPrimalPersistentCharacterStatsStruct.DinoOrderGroups" }; }

    int& CurrentlySelectedDinoOrderGroupField() { return *GetNativePointerField<int*>(this, "FPrimalPersistentCharacterStatsStruct.CurrentlySelectedDinoOrderGroup"); }

    float& PercentageOfHeadHairGrowthField() { return *GetNativePointerField<float*>(this, "FPrimalPersistentCharacterStatsStruct.PercentageOfHeadHairGrowth"); }

    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, bool bSetCurrentStatsToMax) { NativeCall<void, APrimalCharacter*, AShooterPlayerController*, bool, bool>(this, "FPrimalPersistentCharacterStatsStruct.ApplyToPrimalCharacter", aChar, forPC, bIgnoreStats, bSetCurrentStatsToMax); }

    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); }

    void UnlockFeat(FName FeatName) { NativeCall<void, FName>(this, "FPrimalPersistentCharacterStatsStruct.UnlockFeat", FeatName); }

    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& 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"); }

    unsigned int& NextAllowedTerritoryMessageTimeUTCField() { return *GetNativePointerField<unsigned int*>(this, "FPrimalPlayerDataStruct.NextAllowedTerritoryMessageTimeUTC"); }

    unsigned int& NextAllowedTribeJoinTimeUTCField() { return *GetNativePointerField<unsigned int*>(this, "FPrimalPlayerDataStruct.NextAllowedTribeJoinTimeUTC"); }

    unsigned int& BornAtUTCField() { return *GetNativePointerField<unsigned int*>(this, "FPrimalPlayerDataStruct.BornAtUTC"); }

    long double& NextAllowedRespawnTimeField() { return *GetNativePointerField<long double*>(this, "FPrimalPlayerDataStruct.NextAllowedRespawnTime"); }

    long double& LastTimeDiedToEnemyTeamField() { return *GetNativePointerField<long double*>(this, "FPrimalPlayerDataStruct.LastTimeDiedToEnemyTeam"); }

    float& AllowedRespawnIntervalField() { return *GetNativePointerField<float*>(this, "FPrimalPlayerDataStruct.AllowedRespawnInterval"); }

    TArray<FFeatCooldown>& FeatCooldownsField() { return *GetNativePointerField<TArray<FFeatCooldown>*>(this, "FPrimalPlayerDataStruct.FeatCooldowns"); }

    float& NumOfDeathsField() { return *GetNativePointerField<float*>(this, "FPrimalPlayerDataStruct.NumOfDeaths"); }

    int& SpawnDayNumberField() { return *GetNativePointerField<int*>(this, "FPrimalPlayerDataStruct.SpawnDayNumber"); }

    float& SpawnDayTimeField() { return *GetNativePointerField<float*>(this, "FPrimalPlayerDataStruct.SpawnDayTime"); }

    int& LastUniquePaintingIdField() { return *GetNativePointerField<int*>(this, "FPrimalPlayerDataStruct.LastUniquePaintingId"); }

    TArray<short>& CompletedQuestPointOfInterestIDsField() { return *GetNativePointerField<TArray<short>*>(this, "FPrimalPlayerDataStruct.CompletedQuestPointOfInterestIDs"); }

    TArray<short>& CompletedQuestIDsField() { return *GetNativePointerField<TArray<short>*>(this, "FPrimalPlayerDataStruct.CompletedQuestIDs"); }

    TArray<short>& DiscoveredZonesNewField() { return *GetNativePointerField<TArray<short>*>(this, "FPrimalPlayerDataStruct.DiscoveredZonesNew"); }

    int& TotalDiscoveryZonePointsField() { return *GetNativePointerField<int*>(this, "FPrimalPlayerDataStruct.TotalDiscoveryZonePoints"); }


    // 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); }

    bool HasDiscoveredZone(int ZoneId) { return NativeCall<bool, int>(this, "FPrimalPlayerDataStruct.HasDiscoveredZone", ZoneId); }

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

};


struct UPrimalPlayerData

{

    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"); }

    bool& bWaitingForTribeDataLoadField() { return *GetNativePointerField<bool*>(this, "UPrimalPlayerData.bWaitingForTribeDataLoad"); }


    // Functions


    void ApplyToPlayerCharacter(AShooterPlayerState* ForPlayerState, AShooterCharacter* NewPawn) { NativeCall<void, AShooterPlayerState*, AShooterCharacter*>(this, "UPrimalPlayerData.ApplyToPlayerCharacter", ForPlayerState, NewPawn); }

    void ApplyToPlayerState(AShooterPlayerState* aPlayerState) { NativeCall<void, AShooterPlayerState*>(this, "UPrimalPlayerData.ApplyToPlayerState", aPlayerState); }

    void CreatedNewPlayerData(UWorld* ForWorld) { NativeCall<void, UWorld*>(this, "UPrimalPlayerData.CreatedNewPlayerData", ForWorld); }

    AShooterCharacter* FindCharacterForPlayer(UWorld* inWorld) { return NativeCall<AShooterCharacter*, UWorld*>(this, "UPrimalPlayerData.FindCharacterForPlayer", inWorld); }

    static UPrimalPlayerData* GetDataForID(unsigned __int64 PlayerDataID) { return NativeCall<UPrimalPlayerData*, unsigned __int64>(nullptr, "UPrimalPlayerData.GetDataForID", PlayerDataID); }

    AShooterPlayerState* GetPlayerState(AShooterPlayerState* ignorePlayerState, bool bOnlyCheckExistingPlayers) { return NativeCall<AShooterPlayerState*, AShooterPlayerState*, bool>(this, "UPrimalPlayerData.GetPlayerState", ignorePlayerState, bOnlyCheckExistingPlayers); }

    int GetTribeTeamID() { return NativeCall<int>(this, "UPrimalPlayerData.GetTribeTeamID"); }

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

    void GiveInitialItems(int AppID, AShooterPlayerController* ForPC) { NativeCall<void, int, AShooterPlayerController*>(this, "UPrimalPlayerData.GiveInitialItems", AppID, ForPC); }

    void InitForPlayer(AShooterPlayerState* aPlayerState, bool bDontSaveData) { NativeCall<void, AShooterPlayerState*, bool>(this, "UPrimalPlayerData.InitForPlayer", aPlayerState, bDontSaveData); }

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

    bool MatchesPlayer(AShooterPlayerState* aPlayerState, bool bCheckForExistingPlayer) { return NativeCall<bool, AShooterPlayerState*, bool>(this, "UPrimalPlayerData.MatchesPlayer", aPlayerState, bCheckForExistingPlayer); }

    void OnTribeDataLoaded(FTribeData* LoadedTribeData) { NativeCall<void, FTribeData*>(this, "UPrimalPlayerData.OnTribeDataLoaded", LoadedTribeData); }

    void RefreshPersistentBuffs(AShooterCharacter* theChar) { NativeCall<void, AShooterCharacter*>(this, "UPrimalPlayerData.RefreshPersistentBuffs", theChar); }

    void SavePlayerData(UWorld* ForWorld) { NativeCall<void, UWorld*>(this, "UPrimalPlayerData.SavePlayerData", ForWorld); }

    void SetCharacterExperiencePoints(float NewXP) { NativeCall<void, float>(this, "UPrimalPlayerData.SetCharacterExperiencePoints", NewXP); }

    void SetSubscribedApp(int AppID, AShooterPlayerController* ForPC) { NativeCall<void, int, AShooterPlayerController*>(this, "UPrimalPlayerData.SetSubscribedApp", AppID, ForPC); }

    void SetTotalDiscoveryZonePoints(int newPoints) { NativeCall<void, int>(this, "UPrimalPlayerData.SetTotalDiscoveryZonePoints", newPoints); }

    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(UWorld* ForWorld) { NativeCall<void, UWorld*>(this, "UPrimalPlayerData.BPCreatedNewPlayerData", ForWorld); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "UPrimalPlayerData.GetPrivateStaticClass", Package); }

    static void StaticRegisterNativesUPrimalPlayerData() { NativeCall<void>(nullptr, "UPrimalPlayerData.StaticRegisterNativesUPrimalPlayerData"); }

};


struct UPrimalCharacterStatusComponent

{

    FieldArray<float, 16> MaxStatusValuesField() { return { this, "UPrimalCharacterStatusComponent.MaxStatusValues" }; }

    FieldArray<float, 16> BaseLevelMaxStatusValuesField() { return { this, "UPrimalCharacterStatusComponent.BaseLevelMaxStatusValues" }; }

    FieldArray<char, 16> NumberOfLevelUpPointsAppliedField() { return { this, "UPrimalCharacterStatusComponent.NumberOfLevelUpPointsApplied" }; }

    FieldArray<char, 16> NumberOfLevelUpPointsAppliedTamedField() { return { this, "UPrimalCharacterStatusComponent.NumberOfLevelUpPointsAppliedTamed" }; }

    float& TamedIneffectivenessModifierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.TamedIneffectivenessModifier"); }

    float& MovingStaminaRecoveryRateMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.MovingStaminaRecoveryRateMultiplier"); }

    FieldArray<float, 16> RecoveryRateStatusValueField() { return { this, "UPrimalCharacterStatusComponent.RecoveryRateStatusValue" }; }

    FieldArray<float, 16> TimeToRecoverAfterDepletionStatusValueField() { return { this, "UPrimalCharacterStatusComponent.TimeToRecoverAfterDepletionStatusValue" }; }

    FieldArray<float, 16> TimeToRecoverAfterDecreaseStatusValueField() { return { this, "UPrimalCharacterStatusComponent.TimeToRecoverAfterDecreaseStatusValue" }; }

    FieldArray<float, 16> AmountMaxGainedPerLevelUpValueField() { return { this, "UPrimalCharacterStatusComponent.AmountMaxGainedPerLevelUpValue" }; }

    FieldArray<float, 16> AmountMaxGainedPerLevelUpValueTamedField() { return { this, "UPrimalCharacterStatusComponent.AmountMaxGainedPerLevelUpValueTamed" }; }

    FieldArray<char, 16> MaxGainedPerLevelUpValueIsPercentField() { return { this, "UPrimalCharacterStatusComponent.MaxGainedPerLevelUpValueIsPercent" }; }

    FieldArray<char, 16> RecoveryRateIsPercentField() { return { this, "UPrimalCharacterStatusComponent.RecoveryRateIsPercent" }; }

    FieldArray<float, 16> TamingMaxStatMultipliersField() { return { this, "UPrimalCharacterStatusComponent.TamingMaxStatMultipliers" }; }

    FieldArray<float, 16> TamingMaxStatAdditionsField() { return { this, "UPrimalCharacterStatusComponent.TamingMaxStatAdditions" }; }

    FieldArray<float, 16> MaxLevelUpMultiplierField() { return { this, "UPrimalCharacterStatusComponent.MaxLevelUpMultiplier" }; }

    FieldArray<float, 16> ExtraStatusValueRateDecreaseModifiersField() { return { this, "UPrimalCharacterStatusComponent.ExtraStatusValueRateDecreaseModifiers" }; }

    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, 16> CanLevelUpValueField() { return { this, "UPrimalCharacterStatusComponent.CanLevelUpValue" }; }

    FieldArray<char, 16> DontUseValueField() { return { this, "UPrimalCharacterStatusComponent.DontUseValue" }; }

    FieldArray<char, 16> HideValueField() { return { this, "UPrimalCharacterStatusComponent.HideValue" }; }

    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& IncreaseDamageByLevelMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.IncreaseDamageByLevelMultiplier"); }

    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& FortitudeInsulationMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.FortitudeInsulationMultiplier"); }

    float& HypothermalInsulationMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.HypothermalInsulationMultiplier"); }

    float& HyperthermalInsulationMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.HyperthermalInsulationMultiplier"); }

    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& 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& ShipKillEarnXPMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.ShipKillEarnXPMultiplier"); }

    float& DefaultHyperthermicInsulationField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.DefaultHyperthermicInsulation"); }

    float& DefaultHypothermicInsulationField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.DefaultHypothermicInsulation"); }

    float& MaxTamingEffectivenessBaseLevelMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.MaxTamingEffectivenessBaseLevelMultiplier"); }

    TArray<FPrimalCharacterStatusValueModifier>& StatusValueModifiersField() { return *GetNativePointerField<TArray<FPrimalCharacterStatusValueModifier>*>(this, "UPrimalCharacterStatusComponent.StatusValueModifiers"); }

    TArray<unsigned char>& StatusValueModifierDescriptionIndicesField() { return *GetNativePointerField<TArray<unsigned char>*>(this, "UPrimalCharacterStatusComponent.StatusValueModifierDescriptionIndices"); }

    FieldArray<float, 16> CurrentStatusValuesField() { return { this, "UPrimalCharacterStatusComponent.CurrentStatusValues" }; }

    FieldArray<float, 16> AdditionalStatusValuesField() { return { this, "UPrimalCharacterStatusComponent.AdditionalStatusValues" }; }

    FieldArray<float, 16> ReplicatedCurrentStatusValuesField() { return { this, "UPrimalCharacterStatusComponent.ReplicatedCurrentStatusValues" }; }

    FieldArray<float, 16> ReplicatedGlobalMaxStatusValuesField() { return { this, "UPrimalCharacterStatusComponent.ReplicatedGlobalMaxStatusValues" }; }

    FieldArray<float, 16> ReplicatedBaseLevelMaxStatusValuesField() { return { this, "UPrimalCharacterStatusComponent.ReplicatedBaseLevelMaxStatusValues" }; }

    FieldArray<float, 16> ReplicatedGlobalCurrentStatusValuesField() { return { this, "UPrimalCharacterStatusComponent.ReplicatedGlobalCurrentStatusValues" }; }

    FieldArray<char, 16> CurrentStatusStatesField() { return { this, "UPrimalCharacterStatusComponent.CurrentStatusStates" }; }

    FieldArray<long double, 16> LastDecreasedStatusValuesTimesField() { return { this, "UPrimalCharacterStatusComponent.LastDecreasedStatusValuesTimes" }; }

    FieldArray<long double, 16> LastIncreasedStatusValuesTimesField() { return { this, "UPrimalCharacterStatusComponent.LastIncreasedStatusValuesTimes" }; }

    FieldArray<long double, 16> LastMaxedStatusValuesTimesField() { return { this, "UPrimalCharacterStatusComponent.LastMaxedStatusValuesTimes" }; }

    FieldArray<long double, 16> 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& WeightMultiplierForCarriedPassengersField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.WeightMultiplierForCarriedPassengers"); }

    float& WeightMultiplierForPlatformPassengersInventoryField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.WeightMultiplierForPlatformPassengersInventory"); }

    FieldArray<float, 16> DinoMaxStatAddMultiplierImprintingField() { return { this, "UPrimalCharacterStatusComponent.DinoMaxStatAddMultiplierImprinting" }; }

    float& DinoImprintingQualityField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.DinoImprintingQuality"); }

    float& StaminaToTorporMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.StaminaToTorporMultiplier"); }

    float& StaminaToHealthMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.StaminaToHealthMultiplier"); }

    float& StaminaToHealthMaxPercentPerConversionField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.StaminaToHealthMaxPercentPerConversion"); }

    float& TamedBaseHealthMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.TamedBaseHealthMultiplier"); }

    float& MinHealthFromExhaustionField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.MinHealthFromExhaustion"); }

    long double& LastTimeEnteredExhaustedStateField() { return *GetNativePointerField<long double*>(this, "UPrimalCharacterStatusComponent.LastTimeEnteredExhaustedState"); }

    float& TimeBeforeDecreasingTorporAfterExhaustedField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.TimeBeforeDecreasingTorporAfterExhausted"); }

    float& ExtraBabyDinoConsumingFoodRateMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.ExtraBabyDinoConsumingFoodRateMultiplier"); }

    TArray<FString>& StatusValueNameOverridesField() { return *GetNativePointerField<TArray<FString>*>(this, "UPrimalCharacterStatusComponent.StatusValueNameOverrides"); }

    TArray<FString>& StatusDescriptionOverridesField() { return *GetNativePointerField<TArray<FString>*>(this, "UPrimalCharacterStatusComponent.StatusDescriptionOverrides"); }

    TSubclassOf<UDamageType>& RegainOxygenDamageTypeField() { return *GetNativePointerField<TSubclassOf<UDamageType>*>(this, "UPrimalCharacterStatusComponent.RegainOxygenDamageType"); }

    TMap<FName, float, FDefaultSetAllocator, TDefaultMapKeyFuncs<FName, float, 0> >& SkillStatModifiersField() { return *GetNativePointerField<TMap<FName, float, FDefaultSetAllocator, TDefaultMapKeyFuncs<FName, float, 0> >*>(this, "UPrimalCharacterStatusComponent.SkillStatModifiers"); }

    TMap<FName, float, FDefaultSetAllocator, TDefaultMapKeyFuncs<FName, float, 0> >& ItemSkillStatModifiersField() { return *GetNativePointerField<TMap<FName, float, FDefaultSetAllocator, TDefaultMapKeyFuncs<FName, float, 0> >*>(this, "UPrimalCharacterStatusComponent.ItemSkillStatModifiers"); }

    TMap<FName, float, FDefaultSetAllocator, TDefaultMapKeyFuncs<FName, float, 0> >& BuffStatModifiersField() { return *GetNativePointerField<TMap<FName, float, FDefaultSetAllocator, TDefaultMapKeyFuncs<FName, float, 0> >*>(this, "UPrimalCharacterStatusComponent.BuffStatModifiers"); }

    float& DistanceTraveledField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.DistanceTraveled"); }

    FVector& LastRecordedLocationField() { return *GetNativePointerField<FVector*>(this, "UPrimalCharacterStatusComponent.LastRecordedLocation"); }

    float& TravelXPIntervalField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.TravelXPInterval"); }

    float& TravelXPPerIntervalField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.TravelXPPerInterval"); }

    float& OverEatFoodDamageMaxPercentField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.OverEatFoodDamageMaxPercent"); }

    float& OverEatFoodDecreaseHealthRateField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.OverEatFoodDecreaseHealthRate"); }

    float& OverEatFoodScaleDecreaseHealthRateField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.OverEatFoodScaleDecreaseHealthRate"); }

    float& OverEatFoodAbsoluteMaximumClampField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.OverEatFoodAbsoluteMaximumClamp"); }

    float& FoodOverMaxDecreaseMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.FoodOverMaxDecreaseMultiplier"); }

    float& OverDrinkWaterDamageMaxPercentField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.OverDrinkWaterDamageMaxPercent"); }

    float& OverDrinkWaterDecreaseHealthRateField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.OverDrinkWaterDecreaseHealthRate"); }

    float& OverDrinkWaterScaleDecreaseHealthRateField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.OverDrinkWaterScaleDecreaseHealthRate"); }

    float& OverDrinkWaterAbsoluteMaximumClampField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.OverDrinkWaterAbsoluteMaximumClamp"); }

    float& WaterOverMaxDecreaseMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.WaterOverMaxDecreaseMultiplier"); }

    FieldArray<float, 4> BaseVitaminsConsumptionRateField() { return { this, "UPrimalCharacterStatusComponent.BaseVitaminsConsumptionRate" }; }

    FieldArray<float, 4> OverEquilibriumVitaminsConsumptionMultiplierField() { return { this, "UPrimalCharacterStatusComponent.OverEquilibriumVitaminsConsumptionMultiplier" }; }

    FieldArray<float, 4> OverEquilibriumVitaminsAdditionMultiplierField() { return { this, "UPrimalCharacterStatusComponent.OverEquilibriumVitaminsAdditionMultiplier" }; }

    float& VitaminEquilibriumValueField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.VitaminEquilibriumValue"); }

    float& OverweightMinSpeedField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.OverweightMinSpeed"); }

    float& MinSpeedModifierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.MinSpeedModifier"); }

    TArray<UTexture2D*> StatIconOverridesField() { return *GetNativePointerField<TArray<UTexture2D*>*>(this, "UPrimalCharacterStatusComponent.StatIconOverrides"); }

    float& VitaminEquilibriumThresholdPercentField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.VitaminEquilibriumThresholdPercent"); }

    float& FortitudeOxygenReductionResistanceField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.FortitudeOxygenReductionResistance"); }

    float& FortitudeOffshoreVitalsReductionResistanceField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.FortitudeOffshoreVitalsReductionResistance"); }

    float& FortitudeFoodReductionResistanceField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.FortitudeFoodReductionResistance"); }

    float& FortitudeWaterReductionResistanceField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.FortitudeWaterReductionResistance"); }

    float& DinoTamedLevelUpsConstantField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.DinoTamedLevelUpsConstant"); }

    float& DinoTamedLevelUpsBaseMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.DinoTamedLevelUpsBaseMultiplier"); }

    float& FlyingStaminaRecoveryRateMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalCharacterStatusComponent.FlyingStaminaRecoveryRateMultiplier"); }

    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> 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> bCheatStatus() { return { this, "UPrimalCharacterStatusComponent.bCheatStatus" }; }

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

    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" }; }

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

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

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


    // Functions


    void AddExperience(float HowMuch, bool bShareWithTribe, EXPType::Type XPType, bool bShareWithShip) { NativeCall<void, float, bool, EXPType::Type, bool>(this, "UPrimalCharacterStatusComponent.AddExperience", HowMuch, bShareWithTribe, XPType, bShareWithShip); }

    void AddShipExperience(float HowMuch, EXPType::Type XPType, float SharedXPMulti, bool bShareWithBasedPlayers, bool bShareWithBasedNPCCrew, bool bShareWithBasedCreatures, bool bOnlyAddToBasedPawns, APrimalCharacter* FromKillerChar) { NativeCall<void, float, EXPType::Type, float, bool, bool, bool, bool, APrimalCharacter*>(this, "UPrimalCharacterStatusComponent.AddShipExperience", HowMuch, XPType, SharedXPMulti, bShareWithBasedPlayers, bShareWithBasedNPCCrew, bShareWithBasedCreatures, bOnlyAddToBasedPawns, FromKillerChar); }

    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, bool bMoveTowardsEquilibrium, bool bAddTowardsEquilibrium) { NativeCall<void, EPrimalCharacterStatusValue::Type, float, float, bool, bool, int, bool, float, bool, EPrimalCharacterStatusValue::Type, bool, TSubclassOf<UDamageType>, bool, bool>(this, "UPrimalCharacterStatusComponent.AddStatusValueModifier", ValueType, Amount, Speed, bContinueOnUnchangedValue, bSetValue, StatusValueModifierDescriptionIndex, bResetExistingModifierDescriptionIndex, LimitExistingModifierDescriptionToMaxAmount, bSetAdditionalValue, StopAtValueNearMax, bMakeUntameable, ScaleValueByCharacterDamageType, bMoveTowardsEquilibrium, bAddTowardsEquilibrium); }

    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); }

    bool AllowTaming() { return NativeCall<bool>(this, "UPrimalCharacterStatusComponent.AllowTaming"); }

    void ApplyStatusValueModifiers(float DeltaTime) { NativeCall<void, float>(this, "UPrimalCharacterStatusComponent.ApplyStatusValueModifiers", DeltaTime); }

    void ApplyTamingStatModifiers(float TameIneffectivenessModifier) { NativeCall<void, float>(this, "UPrimalCharacterStatusComponent.ApplyTamingStatModifiers", TameIneffectivenessModifier); }

    bool AreAllVitaminsAtEquilibrium() { return NativeCall<bool>(this, "UPrimalCharacterStatusComponent.AreAllVitaminsAtEquilibrium"); }

    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 BPGetAmountGainedPerLevelUpValue(EPrimalCharacterStatusValue::Type valueType, bool bGetTamed) { return NativeCall<float, EPrimalCharacterStatusValue::Type, bool>(this, "UPrimalCharacterStatusComponent.BPGetAmountGainedPerLevelUpValue", valueType, bGetTamed); }

    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); }

    float BPGetRecoveryRateStatusValue(EPrimalCharacterStatusValue::Type valueType) { return NativeCall<float, EPrimalCharacterStatusValue::Type>(this, "UPrimalCharacterStatusComponent.BPGetRecoveryRateStatusValue", valueType); }

    float BPModifyMaxExperiencePoints_Implementation(float InMaxExperiencePoints, bool bCheckingTrueMaximum) { return NativeCall<float, float, bool>(this, "UPrimalCharacterStatusComponent.BPModifyMaxExperiencePoints_Implementation", InMaxExperiencePoints, bCheckingTrueMaximum); }

    int BPModifyMaxLevel_Implementation(int InMaxLevel) { return NativeCall<int, int>(this, "UPrimalCharacterStatusComponent.BPModifyMaxLevel_Implementation", InMaxLevel); }

    void BPSetRecoveryRateStatusValue(EPrimalCharacterStatusValue::Type valueType, float newValue) { NativeCall<void, EPrimalCharacterStatusValue::Type, float>(this, "UPrimalCharacterStatusComponent.BPSetRecoveryRateStatusValue", valueType, newValue); }

    bool CanLevelUp(EPrimalCharacterStatusValue::Type LevelUpValueType) { return NativeCall<bool, EPrimalCharacterStatusValue::Type>(this, "UPrimalCharacterStatusComponent.CanLevelUp", LevelUpValueType); }

    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 ClearAllLevelUpPoints(bool bTamedPoints) { NativeCall<void, bool>(this, "UPrimalCharacterStatusComponent.ClearAllLevelUpPoints", bTamedPoints); }

    void ClientSyncMaxStatusValues_Implementation(TArray<float>* NetMaxStatusValues, TArray<float>* NetBaseMaxStatusValues) { NativeCall<void, TArray<float>*, TArray<float>*>(this, "UPrimalCharacterStatusComponent.ClientSyncMaxStatusValues_Implementation", NetMaxStatusValues, NetBaseMaxStatusValues); }

    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); }

    int GetCharacterLevel() { return NativeCall<int>(this, "UPrimalCharacterStatusComponent.GetCharacterLevel"); }

    float GetConsciousPercentage() { return NativeCall<float>(this, "UPrimalCharacterStatusComponent.GetConsciousPercentage"); }

    float GetCraftingSpeedModifier() { return NativeCall<float>(this, "UPrimalCharacterStatusComponent.GetCraftingSpeedModifier"); }

    UPrimalCharacterStatusComponent* GetDefaultCharacterStatusComponent() { return NativeCall<UPrimalCharacterStatusComponent*>(this, "UPrimalCharacterStatusComponent.GetDefaultCharacterStatusComponent"); }

    void GetDinoFoodConsumptionRateMultiplier(float* Amount) { NativeCall<void, float*>(this, "UPrimalCharacterStatusComponent.GetDinoFoodConsumptionRateMultiplier", Amount); }

    float GetDiscoveryZoneMaxXP(int NumDiscoveredZones) { return NativeCall<float, int>(this, "UPrimalCharacterStatusComponent.GetDiscoveryZoneMaxXP", NumDiscoveredZones); }

    float GetExperiencePercent() { return NativeCall<float>(this, "UPrimalCharacterStatusComponent.GetExperiencePercent"); }

    float GetExperienceRequiredForNextLevelUp() { return NativeCall<float>(this, "UPrimalCharacterStatusComponent.GetExperienceRequiredForNextLevelUp"); }

    float GetExperienceRequiredForPreviousLevelUp() { return NativeCall<float>(this, "UPrimalCharacterStatusComponent.GetExperienceRequiredForPreviousLevelUp"); }

    int GetExtraCharacterLevel() { return NativeCall<int>(this, "UPrimalCharacterStatusComponent.GetExtraCharacterLevel"); }

    float GetJumpZModifier() { return NativeCall<float>(this, "UPrimalCharacterStatusComponent.GetJumpZModifier"); }

    int GetLevelUpPoints(EPrimalCharacterStatusValue::Type valueType, bool bTamedPoints) { return NativeCall<int, EPrimalCharacterStatusValue::Type, bool>(this, "UPrimalCharacterStatusComponent.GetLevelUpPoints", valueType, bTamedPoints); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "UPrimalCharacterStatusComponent.GetLifetimeReplicatedProps", OutLifetimeProps); }

    float GetMaxStatusValue(EPrimalCharacterStatusValue::Type valueType) { return NativeCall<float, EPrimalCharacterStatusValue::Type>(this, "UPrimalCharacterStatusComponent.GetMaxStatusValue", valueType); }

    float GetMeleeDamageModifier() { return NativeCall<float>(this, "UPrimalCharacterStatusComponent.GetMeleeDamageModifier"); }

    float GetMovementSpeedModifier() { return NativeCall<float>(this, "UPrimalCharacterStatusComponent.GetMovementSpeedModifier"); }

    int GetMyCurrentDiscoveryZoneMaxLevel() { return NativeCall<int>(this, "UPrimalCharacterStatusComponent.GetMyCurrentDiscoveryZoneMaxLevel"); }

    float GetMyCurrentDiscoveryZoneMaxXP() { return NativeCall<float>(this, "UPrimalCharacterStatusComponent.GetMyCurrentDiscoveryZoneMaxXP"); }

    float GetMyMaxAllowedXP(bool bCheckingTrueMaximum) { return NativeCall<float, bool>(this, "UPrimalCharacterStatusComponent.GetMyMaxAllowedXP", bCheckingTrueMaximum); }

    int GetNumLevelUpsAvailable() { return NativeCall<int>(this, "UPrimalCharacterStatusComponent.GetNumLevelUpsAvailable"); }

    float GetOffshoreVitalsDecreaseMultiplier() { return NativeCall<float>(this, "UPrimalCharacterStatusComponent.GetOffshoreVitalsDecreaseMultiplier"); }

    APrimalCharacter* GetPrimalCharacter() { return NativeCall<APrimalCharacter*>(this, "UPrimalCharacterStatusComponent.GetPrimalCharacter"); }

    float GetSkillStatModifier(FName SkillStatModifierName) { return NativeCall<float, FName>(this, "UPrimalCharacterStatusComponent.GetSkillStatModifier", SkillStatModifierName); }

    float GetSkillStatMultiplier(FName SkillStatModifierName) { return NativeCall<float, FName>(this, "UPrimalCharacterStatusComponent.GetSkillStatMultiplier", SkillStatModifierName); }

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

    FString* GetStatusMaxValueString(FString* result, EPrimalCharacterStatusValue::Type ValueType, bool bValueOnly) { return NativeCall<FString*, FString*, EPrimalCharacterStatusValue::Type, bool>(this, "UPrimalCharacterStatusComponent.GetStatusMaxValueString", result, ValueType, bValueOnly); }

    FString* GetStatusNameString(FString* result, EPrimalCharacterStatusValue::Type ValueType) { return NativeCall<FString*, FString*, EPrimalCharacterStatusValue::Type>(this, "UPrimalCharacterStatusComponent.GetStatusNameString", result, ValueType); }

    FString* GetStatusStatusDescription(FString* result, EPrimalCharacterStatusValue::Type ValueType) { return NativeCall<FString*, FString*, EPrimalCharacterStatusValue::Type>(this, "UPrimalCharacterStatusComponent.GetStatusStatusDescription", result, ValueType); }

    float GetStatusValueRecoveryRate(EPrimalCharacterStatusValue::Type valueType) { return NativeCall<float, EPrimalCharacterStatusValue::Type>(this, "UPrimalCharacterStatusComponent.GetStatusValueRecoveryRate", valueType); }

    FString* GetStatusValueString(FString* result, EPrimalCharacterStatusValue::Type ValueType, bool bValueOnly) { return NativeCall<FString*, FString*, EPrimalCharacterStatusValue::Type, bool>(this, "UPrimalCharacterStatusComponent.GetStatusValueString", result, ValueType, bValueOnly); }

    float GetSwimmingTemperatureFortitudeMultiplier() { return NativeCall<float>(this, "UPrimalCharacterStatusComponent.GetSwimmingTemperatureFortitudeMultiplier"); }

    float GetThresholdValueForState(EPrimalCharacterStatusValue::Type valueType, char StateIndex, bool bHighThreshold) { return NativeCall<float, EPrimalCharacterStatusValue::Type, char, bool>(this, "UPrimalCharacterStatusComponent.GetThresholdValueForState", valueType, StateIndex, bHighThreshold); }

    float GetTotalStatusModifierDescriptionIndex(int StatusValueModifierDescriptionIndex) { return NativeCall<float, int>(this, "UPrimalCharacterStatusComponent.GetTotalStatusModifierDescriptionIndex", StatusValueModifierDescriptionIndex); }

    float GetUpgradedMaxStatusValue(EPrimalCharacterStatusValue::Type valueType) { return NativeCall<float, EPrimalCharacterStatusValue::Type>(this, "UPrimalCharacterStatusComponent.GetUpgradedMaxStatusValue", valueType); }

    FString* GetUpgradedStatusValueString(FString* result, EPrimalCharacterStatusValue::Type ValueType) { return NativeCall<FString*, FString*, EPrimalCharacterStatusValue::Type>(this, "UPrimalCharacterStatusComponent.GetUpgradedStatusValueString", result, ValueType); }

    bool HasExperienceForLevelUp() { return NativeCall<bool>(this, "UPrimalCharacterStatusComponent.HasExperienceForLevelUp"); }

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

    bool IsAlignedWithTeam(int TargetingTeam) { return NativeCall<bool, int>(this, "UPrimalCharacterStatusComponent.IsAlignedWithTeam", TargetingTeam); }

    bool IsAtMaxLevel() { return NativeCall<bool>(this, "UPrimalCharacterStatusComponent.IsAtMaxLevel"); }

    bool IsInStatusState(EPrimalCharacterStatusState::Type StateType) { return NativeCall<bool, EPrimalCharacterStatusState::Type>(this, "UPrimalCharacterStatusComponent.IsInStatusState", StateType); }

    bool IsVitaminAtEquilibrium(EPrimalCharacterStatusValue::Type VitaminType) { return NativeCall<bool, EPrimalCharacterStatusValue::Type>(this, "UPrimalCharacterStatusComponent.IsVitaminAtEquilibrium", VitaminType); }

    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 NetSyncMaxStatusValues_Implementation(TArray<float>* NetMaxStatusValues, TArray<float>* NetBaseMaxStatusValues) { NativeCall<void, TArray<float>*, TArray<float>*>(this, "UPrimalCharacterStatusComponent.NetSyncMaxStatusValues_Implementation", NetMaxStatusValues, NetBaseMaxStatusValues); }

    void OnDeserializedByGame(EOnDesrializationType::Type DeserializationType) { NativeCall<void, EOnDesrializationType::Type>(this, "UPrimalCharacterStatusComponent.OnDeserializedByGame", DeserializationType); }

    void OnJumped() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.OnJumped"); }

    void OnRep_CurrentStatusValues() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.OnRep_CurrentStatusValues"); }

    void OnRep_GlobalBaseLevelMaxStatusValues() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.OnRep_GlobalBaseLevelMaxStatusValues"); }

    void OnRep_GlobalCurrentStatusValues() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.OnRep_GlobalCurrentStatusValues"); }

    void OnRep_GlobalMaxStatusValues() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.OnRep_GlobalMaxStatusValues"); }

    void OnRep_ReplicatedExperiencePoints() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.OnRep_ReplicatedExperiencePoints"); }

    void RefreshBuffStatGroupModifiers() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.RefreshBuffStatGroupModifiers"); }

    void RefreshEquippedItemStatGroupModifiers() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.RefreshEquippedItemStatGroupModifiers"); }

    void RefreshInsulation() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.RefreshInsulation"); }

    void RefreshTemperature() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.RefreshTemperature"); }

    void RescaleAllStats() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.RescaleAllStats"); }

    void RescaleMaxStat(EPrimalCharacterStatusValue::Type LevelUpValueType, float TargetValue, bool bIsPercentOfTrueValue) { NativeCall<void, EPrimalCharacterStatusValue::Type, float, bool>(this, "UPrimalCharacterStatusComponent.RescaleMaxStat", LevelUpValueType, TargetValue, bIsPercentOfTrueValue); }

    void ServerApplyLevelUp(EPrimalCharacterStatusValue::Type LevelUpValueType, AShooterPlayerController* ByPC) { NativeCall<void, EPrimalCharacterStatusValue::Type, AShooterPlayerController*>(this, "UPrimalCharacterStatusComponent.ServerApplyLevelUp", LevelUpValueType, ByPC); }

    void ServerSyncReplicatedValues() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.ServerSyncReplicatedValues"); }

    void SetBaseLevel(int Level, bool bDontCurrentSetToMax) { NativeCall<void, int, bool>(this, "UPrimalCharacterStatusComponent.SetBaseLevel", Level, bDontCurrentSetToMax); }

    void SetExtraCharacterLevel(int NewExtraCharacterLevel) { NativeCall<void, int>(this, "UPrimalCharacterStatusComponent.SetExtraCharacterLevel", NewExtraCharacterLevel); }

    void SetLevelUpPoints(EPrimalCharacterStatusValue::Type valueType, bool bTamedPoints, int newPoints) { NativeCall<void, EPrimalCharacterStatusValue::Type, bool, int>(this, "UPrimalCharacterStatusComponent.SetLevelUpPoints", valueType, bTamedPoints, newPoints); }

    void SetMaxStatusValue(EPrimalCharacterStatusValue::Type StatType, float newValue) { NativeCall<void, EPrimalCharacterStatusValue::Type, float>(this, "UPrimalCharacterStatusComponent.SetMaxStatusValue", StatType, newValue); }

    void SetTameable(bool bTameable) { NativeCall<void, bool>(this, "UPrimalCharacterStatusComponent.SetTameable", bTameable); }

    void SetTamed(float TameIneffectivenessModifier) { NativeCall<void, float>(this, "UPrimalCharacterStatusComponent.SetTamed", TameIneffectivenessModifier); }

    void TickStatus(float DeltaTime, bool bForceStatusUpdate) { NativeCall<void, float, bool>(this, "UPrimalCharacterStatusComponent.TickStatus", DeltaTime, bForceStatusUpdate); }

    void TransferStatusAmountIfNeeded(EPrimalCharacterStatusValue::Type valueType, float* Amount, bool bPercentOfMax, bool bPercentOfCurrent, bool bManualModification, bool bSetValue, TSubclassOf<UDamageType> DamageTypeClass, bool bDamageDontKill, bool bForceSetValue) { NativeCall<void, EPrimalCharacterStatusValue::Type, float*, bool, bool, bool, bool, TSubclassOf<UDamageType>, bool, bool>(this, "UPrimalCharacterStatusComponent.TransferStatusAmountIfNeeded", valueType, Amount, bPercentOfMax, bPercentOfCurrent, bManualModification, bSetValue, DamageTypeClass, bDamageDontKill, bForceSetValue); }

    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 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); }

    void UpdatedStatModifiers() { NativeCall<void>(this, "UPrimalCharacterStatusComponent.UpdatedStatModifiers"); }

    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, bool bCheckingTrueMaximum) { return NativeCall<float, float, bool>(this, "UPrimalCharacterStatusComponent.BPModifyMaxExperiencePoints", InMaxExperiencePoints, bCheckingTrueMaximum); }

    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); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "UPrimalCharacterStatusComponent.GetPrivateStaticClass", Package); }

    void NetSyncMaxStatusValues(TArray<float>* NetMaxStatusValues, TArray<float>* NetBaseMaxStatusValues) { NativeCall<void, TArray<float>*, TArray<float>*>(this, "UPrimalCharacterStatusComponent.NetSyncMaxStatusValues", NetMaxStatusValues, NetBaseMaxStatusValues); }

    static void StaticRegisterNativesUPrimalCharacterStatusComponent() { NativeCall<void>(nullptr, "UPrimalCharacterStatusComponent.StaticRegisterNativesUPrimalCharacterStatusComponent"); }

};


struct  FDamageHarvestingEntry

{

    float DamageMultiplier;

    float HarvestQuantityMultiplier;

    float DamageHarvestAdditionalEffectiveness;

    float DamageDurabilityConsumptionMultiplier;

    __int8 bAllowUnderwaterHarvesting : 1;

    TSubclassOf<UDamageType> DamageTypeParent;

    TSubclassOf<AActor> HarvestDamageFXOverride;

};


struct FOverrideDamageHarvestingEntry

{

    TArray<TSubclassOf<UPrimalHarvestingComponent>, FDefaultAllocator> ForHarvestingComponents;

    FDamageHarvestingEntry HarvestEntryOverride;

    TArray<FHarvestResourceEntry, FDefaultAllocator> HarvestResourceEntriesOverride;

};


struct UShooterDamageType : UDamageType

{

    //TSubclassOf<AShooterImpactEffect>& HitTargetableActorImpactEffectsField() { return *GetNativePointerField<TSubclassOf<AShooterImpactEffect>*>(this, "UShooterDamageType.HitTargetableActorImpactEffects"); }

    float& DamageTorpidityIncreaseMultiplierField() { return *GetNativePointerField<float*>(this, "UShooterDamageType.DamageTorpidityIncreaseMultiplier"); }

    TArray<FDamagePrimalCharacterStatusValueModifier>& DamageCharacterStatusValueModifiersField() { return *GetNativePointerField<TArray<FDamagePrimalCharacterStatusValueModifier>*>(this, "UShooterDamageType.DamageCharacterStatusValueModifiers"); }

    float& DamageInstigatorPercentageField() { return *GetNativePointerField<float*>(this, "UShooterDamageType.DamageInstigatorPercentage"); }

    float& UseSpecialDamageIntervalField() { return *GetNativePointerField<float*>(this, "UShooterDamageType.UseSpecialDamageInterval"); }

    TSubclassOf<APrimalBuff>& BuffToGiveVictimCharacterField() { return *GetNativePointerField<TSubclassOf<APrimalBuff>*>(this, "UShooterDamageType.BuffToGiveVictimCharacter"); }

    float& MassScaleDamageImpulseExponentField() { return *GetNativePointerField<float*>(this, "UShooterDamageType.MassScaleDamageImpulseExponent"); }

    float& MythicalCreatureDamageMultiplierField() { return *GetNativePointerField<float*>(this, "UShooterDamageType.MythicalCreatureDamageMultiplier"); }

    TArray<TSubclassOf<AActor>>& DamageIgnoreActorClassesField() { return *GetNativePointerField<TArray<TSubclassOf<AActor>>*>(this, "UShooterDamageType.DamageIgnoreActorClasses"); }

    TArray<TSubclassOf<AActor>>& DamageOnlyActorClassesField() { return *GetNativePointerField<TArray<TSubclassOf<AActor>>*>(this, "UShooterDamageType.DamageOnlyActorClasses"); }

    TArray<FOverrideDamageHarvestingEntry>& OverrideDamageHarvestEntriesField() { return *GetNativePointerField<TArray<FOverrideDamageHarvestingEntry>*>(this, "UShooterDamageType.OverrideDamageHarvestEntries"); }

    TSubclassOf<UDamageType>& InvalidHarvestOverrideDamageTypeField() { return *GetNativePointerField<TSubclassOf<UDamageType>*>(this, "UShooterDamageType.InvalidHarvestOverrideDamageType"); }

    //TArray<FTargetClassDamageScaler>& TargetClassDamageScalersField() { return *GetNativePointerField<TArray<FTargetClassDamageScaler>*>(this, "UShooterDamageType.TargetClassDamageScalers"); }

    TArray<TSubclassOf<UPrimalItem>>& OverrideDamageForResourceHarvestingItemsField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalItem>>*>(this, "UShooterDamageType.OverrideDamageForResourceHarvestingItems"); }

    TArray<TSubclassOf<UDamageType>>& OverrideDamageForResourceHarvestingDamageTypesField() { return *GetNativePointerField<TArray<TSubclassOf<UDamageType>>*>(this, "UShooterDamageType.OverrideDamageForResourceHarvestingDamageTypes"); }

    float& HitMarkerScaleMultiplierField() { return *GetNativePointerField<float*>(this, "UShooterDamageType.HitMarkerScaleMultiplier"); }

    float& PostShieldDefenseBrokenAttackValueField() { return *GetNativePointerField<float*>(this, "UShooterDamageType.PostShieldDefenseBrokenAttackValue"); }

    float& PostShieldDefenseBrokenDamageScaleMinField() { return *GetNativePointerField<float*>(this, "UShooterDamageType.PostShieldDefenseBrokenDamageScaleMin"); }

    float& PostShieldDefenseBrokenDamageScaleMaxField() { return *GetNativePointerField<float*>(this, "UShooterDamageType.PostShieldDefenseBrokenDamageScaleMax"); }

    float& NonAttackDataShieldDefenseBreakingPowerField() { return *GetNativePointerField<float*>(this, "UShooterDamageType.NonAttackDataShieldDefenseBreakingPower"); }

    TSubclassOf<APrimalBuff>& NonAttackDataBuffToGiveAgainstShieldField() { return *GetNativePointerField<TSubclassOf<APrimalBuff>*>(this, "UShooterDamageType.NonAttackDataBuffToGiveAgainstShield"); }

    TSubclassOf<APrimalBuff>& NonAttackDataBuffToGivePostShieldDefenseBrokenField() { return *GetNativePointerField<TSubclassOf<APrimalBuff>*>(this, "UShooterDamageType.NonAttackDataBuffToGivePostShieldDefenseBroken"); }


    // Bit fields


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


    // Functions


    float BPAdjustDamage(AActor* Victim, float IncomingDamage, FDamageEvent* TheDamageEvent, AController* EventInstigator, AActor* DamageCauser) { return NativeCall<float, AActor*, float, FDamageEvent*, AController*, AActor*>(this, "UShooterDamageType.BPAdjustDamage", Victim, IncomingDamage, TheDamageEvent, EventInstigator, DamageCauser); }

    float BPAdjustHarvestingDamage(AActor* Victim, float IncomingDamage, FDamageEvent* TheDamageEvent, AController* EventInstigator, AActor* DamageCauser) { return NativeCall<float, AActor*, float, FDamageEvent*, AController*, AActor*>(this, "UShooterDamageType.BPAdjustHarvestingDamage", Victim, IncomingDamage, TheDamageEvent, EventInstigator, DamageCauser); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "UShooterDamageType.GetPrivateStaticClass", Package); }

    TSubclassOf<APrimalBuff>* OverrideBuffToGiveVictimCharacter(TSubclassOf<APrimalBuff>* result, APrimalCharacter* Victim, float IncomingDamage, FDamageEvent* TheDamageEvent, AController* EventInstigator, AActor* DamageCauser) { return NativeCall<TSubclassOf<APrimalBuff>*, TSubclassOf<APrimalBuff>*, APrimalCharacter*, float, FDamageEvent*, AController*, AActor*>(this, "UShooterDamageType.OverrideBuffToGiveVictimCharacter", result, Victim, IncomingDamage, TheDamageEvent, EventInstigator, DamageCauser); }

    static void StaticRegisterNativesUShooterDamageType() { NativeCall<void>(nullptr, "UShooterDamageType.StaticRegisterNativesUShooterDamageType"); }

};


struct  FDinoFoodEffectivenessMultipliers

{

    float FoodEffectivenessMultiplier;

    float HealthEffectivenessMultiplier;

    float TorpidityEffectivenessMultiplier;

    float AffinityEffectivenessMultiplier;

    float AffinityOverride;

    float StaminaEffectivenessMultiplier;

    int FoodItemCategory;

    TSubclassOf<UPrimalItem> FoodItemParent;

    float UntamedFoodConsumptionPriority;

};


struct UPrimalDinoSettings : UObject

{

    TArray<FDinoFoodEffectivenessMultipliers>& FoodEffectivenessMultipliersField() { return *GetNativePointerField<TArray<FDinoFoodEffectivenessMultipliers>*>(this, "UPrimalDinoSettings.FoodEffectivenessMultipliers"); }

    TArray<FDinoFoodEffectivenessMultipliers>& ExtraFoodEffectivenessMultipliersField() { return *GetNativePointerField<TArray<FDinoFoodEffectivenessMultipliers>*>(this, "UPrimalDinoSettings.ExtraFoodEffectivenessMultipliers"); }

    float& TamingAffinityNoFoodDecreasePercentageSpeedField() { return *GetNativePointerField<float*>(this, "UPrimalDinoSettings.TamingAffinityNoFoodDecreasePercentageSpeed"); }

    float& TamingIneffectivenessNoFoodIncreasePercentageSpeedMultiplierField() { return *GetNativePointerField<float*>(this, "UPrimalDinoSettings.TamingIneffectivenessNoFoodIncreasePercentageSpeedMultiplier"); }

    int& DinoTierNumField() { return *GetNativePointerField<int*>(this, "UPrimalDinoSettings.DinoTierNum"); }

    TSubclassOf<UPrimalEngramEntry>& RequiresSkillToTameField() { return *GetNativePointerField<TSubclassOf<UPrimalEngramEntry>*>(this, "UPrimalDinoSettings.RequiresSkillToTame"); }

    TSubclassOf<UPrimalEngramEntry>& RequiresSkillToRideField() { return *GetNativePointerField<TSubclassOf<UPrimalEngramEntry>*>(this, "UPrimalDinoSettings.RequiresSkillToRide"); }

    TSubclassOf<UPrimalEngramEntry>& RequiresSkillToCommandField() { return *GetNativePointerField<TSubclassOf<UPrimalEngramEntry>*>(this, "UPrimalDinoSettings.RequiresSkillToCommand"); }

    TSubclassOf<UPrimalEngramEntry>& RequiresSkillToImprintField() { return *GetNativePointerField<TSubclassOf<UPrimalEngramEntry>*>(this, "UPrimalDinoSettings.RequiresSkillToImprint"); }

    UTexture2D* DinoFoodTypeImageField() { return *GetNativePointerField<UTexture2D * *>(this, "UPrimalDinoSettings.DinoFoodTypeImage"); }

    FString& DinoFoodTypeNameField() { return *GetNativePointerField<FString*>(this, "UPrimalDinoSettings.DinoFoodTypeName"); }

    FString& FeedToTameStringField() { return *GetNativePointerField<FString*>(this, "UPrimalDinoSettings.FeedToTameString"); }

    FString& FeedItemInLastSlotStringField() { return *GetNativePointerField<FString*>(this, "UPrimalDinoSettings.FeedItemInLastSlotString"); }

    FString& FeedInLastSlotStringField() { return *GetNativePointerField<FString*>(this, "UPrimalDinoSettings.FeedInLastSlotString"); }

    FString& MinLevelForFeedingStringField() { return *GetNativePointerField<FString*>(this, "UPrimalDinoSettings.MinLevelForFeedingString"); }

    //TArray<FSpecialDeathLootEntry>& SpecialDeathLootEntriesField() { return *GetNativePointerField<TArray<FSpecialDeathLootEntry>*>(this, "UPrimalDinoSettings.SpecialDeathLootEntries"); }

    bool& bWakingTameDisplayItemNameField() { return *GetNativePointerField<bool*>(this, "UPrimalDinoSettings.bWakingTameDisplayItemName"); }

    FString& WakingTameDisplayItemNameOverrideField() { return *GetNativePointerField<FString*>(this, "UPrimalDinoSettings.WakingTameDisplayItemNameOverride"); }


    // Functions


    void SpawnWildDinoSpecialDeathLoot_Implementation(APrimalDinoCharacter* ForDino, APawn* InstigatingPawn, AActor* DamageCauser) { NativeCall<void, APrimalDinoCharacter*, APawn*, AActor*>(this, "UPrimalDinoSettings.SpawnWildDinoSpecialDeathLoot_Implementation", ForDino, InstigatingPawn, DamageCauser); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "UPrimalDinoSettings.GetPrivateStaticClass", Package); }

    void SpawnWildDinoSpecialDeathLoot(APrimalDinoCharacter* ForDino, APawn* InstigatingPawn, AActor* DamageCauser) { NativeCall<void, APrimalDinoCharacter*, APawn*, AActor*>(this, "UPrimalDinoSettings.SpawnWildDinoSpecialDeathLoot", ForDino, InstigatingPawn, DamageCauser); }

    static void StaticRegisterNativesUPrimalDinoSettings() { NativeCall<void>(nullptr, "UPrimalDinoSettings.StaticRegisterNativesUPrimalDinoSettings"); }

};


struct FWeightedObjectList

{

    TArray<float, FDefaultAllocator> Weights;

    TArray<UObject*, FDefaultAllocator> AssociatedObjects;

};


struct APrimalDinoCharacter : APrimalCharacter

{

    FWeightedObjectList& DeathInventoryTemplatesField() { return *GetNativePointerField<FWeightedObjectList*>(this, "APrimalDinoCharacter.DeathInventoryTemplates"); }


    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"); }

    float& ColorizationIntensityField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ColorizationIntensity"); }

    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"); }

    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& 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"); }

    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"); }

    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"); }

    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& 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& AutoFadeOutAfterTameTimeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AutoFadeOutAfterTameTime"); }

    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> ColorSetIndicesField() { return { this, "APrimalDinoCharacter.ColorSetIndices" }; }

    FieldArray<float, 6> ColorSetIntensityMultipliersField() { return { this, "APrimalDinoCharacter.ColorSetIntensityMultipliers" }; }

    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"); }

    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& 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"); }

    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"); }

    int& MaxSaddleStructuresHeightField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.MaxSaddleStructuresHeight"); }

    int& SaddlePivotOffsetField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.SaddlePivotOffset"); }

    int& MaxSaddleStructuresNumField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.MaxSaddleStructuresNum"); }

    float& OverTameLimitDamagePercentPerIntervalField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.OverTameLimitDamagePercentPerInterval"); }

    float& OverTameLimitDamageIntervalField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.OverTameLimitDamageInterval"); }

    long double& LastOverTameLimitDamageTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastOverTameLimitDamageTime"); }

    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"); }

    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"); }

    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"); }

    FVector& FirstSpawnLocationField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoCharacter.FirstSpawnLocation"); }

    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"); }

    int& LastInAllyRangeTimeSerializedField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.LastInAllyRangeTimeSerialized"); }

    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& PreviousRootYawSpeedField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.PreviousRootYawSpeed"); }

    long double& LastTimeFallingField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastTimeFalling"); }

    float& FloatingHUDTextScaleField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.FloatingHUDTextScale"); }

    float& FloatingHUDTextScaleMinField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.FloatingHUDTextScaleMin"); }

    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"); }

    float& WildAmbientHarvestingRadiusField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WildAmbientHarvestingRadius"); }

    int& FlyerNumUnderGroundFailField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.FlyerNumUnderGroundFail"); }

    int& AbsoluteBaseLevelField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.AbsoluteBaseLevel"); }

    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"); }

    float& BabyWrongTemperatureHealthPercentDecreaseField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.BabyWrongTemperatureHealthPercentDecrease"); }

    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"); }

    long double& LastTamedFlyerNearbyAllyCheckTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastTamedFlyerNearbyAllyCheckTime"); }

    TSet<FName, DefaultKeyFuncs<FName, 0>, FDefaultSetAllocator>& MatingRequiresBiomeTagsSetField() { return *GetNativePointerField<TSet<FName, DefaultKeyFuncs<FName, 0>, FDefaultSetAllocator>*>(this, "APrimalDinoCharacter.MatingRequiresBiomeTagsSet"); }

    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& XPEarnMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.XPEarnMultiplier"); }

    TArray<FName>& MatingRequiresBiomeTagsField() { return *GetNativePointerField<TArray<FName>*>(this, "APrimalDinoCharacter.MatingRequiresBiomeTags"); }

    float& FemaleMatingRangeAdditionField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.FemaleMatingRangeAddition"); }

    float& FemaleMatingTimeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.FemaleMatingTime"); }

    FName& SaddledRiderSocketNameField() { return *GetNativePointerField<FName*>(this, "APrimalDinoCharacter.SaddledRiderSocketName"); }

    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"); }

    long double& LastMatingWrongTemperatureNotificationTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastMatingWrongTemperatureNotificationTime"); }

    APrimalDinoCharacter* MatingWithDinoField() { return *GetNativePointerField<APrimalDinoCharacter * *>(this, "APrimalDinoCharacter.MatingWithDino"); }

    UAnimMontage* MatingAnimationMaleField() { return *GetNativePointerField<UAnimMontage * *>(this, "APrimalDinoCharacter.MatingAnimationMale"); }

    long double& LastAmbientHarvestingAttackTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastAmbientHarvestingAttackTime"); }

    long double& PreviousAmbientTemperatureTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.PreviousAmbientTemperatureTime"); }

    float& HypoThermalInsulationField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.HypoThermalInsulation"); }

    float& HyperThermalInsulationField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.HyperThermalInsulation"); }

    float& CachedAmbientTemperatureField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.CachedAmbientTemperature"); }

    float& GlobalSpawnEntryWeightMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.GlobalSpawnEntryWeightMultiplier"); }

    FieldArray<char, 16> 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"); }

    USoundBase* StingerKilledMineField() { return *GetNativePointerField<USoundBase * *>(this, "APrimalDinoCharacter.StingerKilledMine"); }

    USoundBase* StingerKilledTheirsField() { return *GetNativePointerField<USoundBase * *>(this, "APrimalDinoCharacter.StingerKilledTheirs"); }

    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"); }

    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"); }

    FString& TutorialHintStringField() { return *GetNativePointerField<FString*>(this, "APrimalDinoCharacter.TutorialHintString"); }

    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& RemainingXPPerHitField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.RemainingXPPerHit"); }

    TSubclassOf<APrimalBuff>& AlphaDinoBuffField() { return *GetNativePointerField<TSubclassOf<APrimalBuff>*>(this, "APrimalDinoCharacter.AlphaDinoBuff"); }

    float& AlphaXPMultiplierMinLevelField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AlphaXPMultiplierMinLevel"); }

    float& AlphaXPMultiplierMaxLevelField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AlphaXPMultiplierMaxLevel"); }

    float& AlphaHarvestComponentHealthMultiplierMinLevelField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AlphaHarvestComponentHealthMultiplierMinLevel"); }

    float& AlphaHarvestComponentHealthMultiplierMaxLevelField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AlphaHarvestComponentHealthMultiplierMaxLevel"); }

    float& AlphaLeveledDamageMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AlphaLeveledDamageMultiplier"); }

    float& WildLeveledDamageMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WildLeveledDamageMultiplier"); }

    float& TamedLeveledDamageMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TamedLeveledDamageMultiplier"); }

    float& AlphaResistanceMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AlphaResistanceMultiplier"); }

    float& AlphaPercentageChanceField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AlphaPercentageChance"); }

    float& AlphaLevelMinField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AlphaLevelMin"); }

    float& AlphaLevelMaxField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.AlphaLevelMax"); }

    int& ReplicateHighlightTagTeamField() { return *GetNativePointerField<int*>(this, "APrimalDinoCharacter.ReplicateHighlightTagTeam"); }

    float& EnemyDrawFloatingHUDLimitDistanceField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.EnemyDrawFloatingHUDLimitDistance"); }

    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"); }

    float& WanderRadiusMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WanderRadiusMultiplier"); }

    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"); }

    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"); }

    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<UPrimalEngramEntry>>& DeathGiveEngramClassesField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalEngramEntry>>*>(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"); }

    long double& IgnoreZeroVelocityNoPreFrameTickingTillField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.IgnoreZeroVelocityNoPreFrameTickingTill"); }

    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"); }

    FName& NonDedicatedFreezeWildDinoPhysicsIfLevelUnloadedField() { return *GetNativePointerField<FName*>(this, "APrimalDinoCharacter.NonDedicatedFreezeWildDinoPhysicsIfLevelUnloaded"); }

    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"); }

    TArray<FSaddlePassengerSeatDefinition>& SaddlePassengerSeatOverridesField() { return *GetNativePointerField<TArray<FSaddlePassengerSeatDefinition>*>(this, "APrimalDinoCharacter.SaddlePassengerSeatOverrides"); }

    UAnimSequence* OverrideSaddleDinoRiderAnimationOverrideField() { return *GetNativePointerField<UAnimSequence * *>(this, "APrimalDinoCharacter.OverrideSaddleDinoRiderAnimationOverride"); }

    UAnimSequence* OverrideSaddleDinoRiderMoveAnimationOverrideField() { return *GetNativePointerField<UAnimSequence * *>(this, "APrimalDinoCharacter.OverrideSaddleDinoRiderMoveAnimationOverride"); }

    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"); }

    char& CurrentPassengerSeatIndexField() { return *GetNativePointerField<char*>(this, "APrimalDinoCharacter.CurrentPassengerSeatIndex"); }

    float& ExtraUntamedNetworkAndStasisRangeMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ExtraUntamedNetworkAndStasisRangeMultiplier"); }

    TArray<TWeakObjectPtr<APrimalCharacter>>& AbsoluteVehicleBasedCharactersField() { return *GetNativePointerField<TArray<TWeakObjectPtr<APrimalCharacter>>*>(this, "APrimalDinoCharacter.AbsoluteVehicleBasedCharacters"); }

    TArray<TWeakObjectPtr<UPrimitiveComponent>>& AbsoluteVehicleBasedCharactersBasesField() { return *GetNativePointerField<TArray<TWeakObjectPtr<UPrimitiveComponent>>*>(this, "APrimalDinoCharacter.AbsoluteVehicleBasedCharactersBases"); }

    long double& LastTimeSwimSuffocatingField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.LastTimeSwimSuffocating"); }

    float& NPC_UsableStructureCheck_RadiusField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.NPC_UsableStructureCheck_Radius"); }

    ANPCZoneManager* DirectLinkedNPCZoneManagerField() { return *GetNativePointerField<ANPCZoneManager * *>(this, "APrimalDinoCharacter.DirectLinkedNPCZoneManager"); }

    float& DirectLinkedNPCZoneManagerSpawnWeightField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.DirectLinkedNPCZoneManagerSpawnWeight"); }

    float& TheMaxHealthPercentageForBolaField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TheMaxHealthPercentageForBola"); }

    float& WildDinoBolaTrapTimeOverrideField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WildDinoBolaTrapTimeOverride"); }

    float& TamedDinoBolaTrapTimeOverrideField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TamedDinoBolaTrapTimeOverride"); }

    float& WildDinoBolaEscapeSetHealthToMinPercentField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WildDinoBolaEscapeSetHealthToMinPercent"); }

    float& MinTemperatureToBreedField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.MinTemperatureToBreed"); }

    float& MaxTemperatureToBreedField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.MaxTemperatureToBreed"); }

    float& TemperatureToBreedInsulationMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.TemperatureToBreedInsulationMultiplier"); }

    float& WakingTameAffinityDecreaseGracePeriodField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WakingTameAffinityDecreaseGracePeriod"); }

    float& ShipImpactDamageMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ShipImpactDamageMultiplier"); }

    float& ShipImpactImpulseMultiplierField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ShipImpactImpulseMultiplier"); }

    TSubclassOf<APrimalStructure>& DinoFeedingContainerClassField() { return *GetNativePointerField<TSubclassOf<APrimalStructure>*>(this, "APrimalDinoCharacter.DinoFeedingContainerClass"); }

    UTexture2D* ReplicatedTeamHighlightTagTextureField() { return *GetNativePointerField<UTexture2D * *>(this, "APrimalDinoCharacter.ReplicatedTeamHighlightTagTexture"); }

    FItemNetID& DeathIncrementClipAmmoItemIDField() { return *GetNativePointerField<FItemNetID*>(this, "APrimalDinoCharacter.DeathIncrementClipAmmoItemID"); }

    TWeakObjectPtr<UPrimalInventoryComponent>& DeathIncrementClipAmmoInventoryField() { return *GetNativePointerField<TWeakObjectPtr<UPrimalInventoryComponent>*>(this, "APrimalDinoCharacter.DeathIncrementClipAmmoInventory"); }

    TArray<ADroppedItem*> DroppedItemsOnMeField() { return *GetNativePointerField<TArray<ADroppedItem*>*>(this, "APrimalDinoCharacter.DroppedItemsOnMe"); }

    FString& DemolishStringOverrideField() { return *GetNativePointerField<FString*>(this, "APrimalDinoCharacter.DemolishStringOverride"); }

    float& WildPostSeamlessTravelStasisAutoDestroyIntervalMinField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WildPostSeamlessTravelStasisAutoDestroyIntervalMin"); }

    float& WildPostSeamlessTravelStasisAutoDestroyIntervalMaxField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.WildPostSeamlessTravelStasisAutoDestroyIntervalMax"); }

    FVector& NPCSpawnLocOffsetField() { return *GetNativePointerField<FVector*>(this, "APrimalDinoCharacter.NPCSpawnLocOffset"); }

    TSubclassOf<APrimalBuff>& RiderBuffField() { return *GetNativePointerField<TSubclassOf<APrimalBuff>*>(this, "APrimalDinoCharacter.RiderBuff"); }

    float& Teleport_OnRaft_AllowedWithinRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.Teleport_OnRaft_AllowedWithinRange"); }

    float& Teleport_OffRaft_AllowedWithinRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.Teleport_OffRaft_AllowedWithinRange"); }

    float& Teleport_BetweenRafts_AllowedWithinRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.Teleport_BetweenRafts_AllowedWithinRange"); }

    float& Teleport_OffRaft_MaxDistField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.Teleport_OffRaft_MaxDist"); }

    float& ExtraStasisComponentCollisionPlayerRelevantRangeField() { return *GetNativePointerField<float*>(this, "APrimalDinoCharacter.ExtraStasisComponentCollisionPlayerRelevantRange"); }

    FString& ForceUnlockDiscoveryZoneNameField() { return *GetNativePointerField<FString*>(this, "APrimalDinoCharacter.ForceUnlockDiscoveryZoneName"); }

    long double& ForceClearMoveIgnoreActorsTimeField() { return *GetNativePointerField<long double*>(this, "APrimalDinoCharacter.ForceClearMoveIgnoreActorsTime"); }

    TSubclassOf<APrimalBuff>& MountedBuffField() { return *GetNativePointerField<TSubclassOf<APrimalBuff>*>(this, "APrimalDinoCharacter.MountedBuff"); }


    // 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> bRetainCarriedCharacterOnDismount() { return { this, "APrimalDinoCharacter.bRetainCarriedCharacterOnDismount" }; }

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

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

    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> 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> 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> 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> 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> 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> 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> 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> bIgnoreServerTamedTick() { return { this, "APrimalDinoCharacter.bIgnoreServerTamedTick" }; }

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

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

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

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

    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> 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> 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> bDrawHealthBar() { return { this, "APrimalDinoCharacter.bDrawHealthBar" }; }

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

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

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

    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> 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> 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> 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> bUseBPGetDragSocketDinoName() { return { this, "APrimalDinoCharacter.bUseBPGetDragSocketDinoName" }; }

    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> bOnlyTargetConscious() { return { this, "APrimalDinoCharacter.bOnlyTargetConscious" }; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    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> 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> bUseBPOnStartCharging() { return { this, "APrimalDinoCharacter.bUseBPOnStartCharging" }; }


    // Functions


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

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

    bool AllowPushOthers() { return NativeCall<bool>(this, "APrimalDinoCharacter.AllowPushOthers"); }

    float GetXPMultiplier() { return NativeCall<float>(this, "APrimalDinoCharacter.GetXPMultiplier"); }

    bool IsVehicle() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsVehicle"); }

    void AddBasedPawn(AActor* anPawn) { NativeCall<void, AActor*>(this, "APrimalDinoCharacter.AddBasedPawn", anPawn); }

    void AddDinoReferenceInLatchingStructure(APrimalStructure* Structure) { NativeCall<void, APrimalStructure*>(this, "APrimalDinoCharacter.AddDinoReferenceInLatchingStructure", Structure); }

    void AddFlyerTakeOffImpulse() { NativeCall<void>(this, "APrimalDinoCharacter.AddFlyerTakeOffImpulse"); }

    bool AddPassenger(APrimalCharacter* Character, int PassengerSeatIndex, bool bForcePassenger, bool bAllowFlyersAndWaterDinos) { return NativeCall<bool, APrimalCharacter*, int, bool, bool>(this, "APrimalDinoCharacter.AddPassenger", Character, PassengerSeatIndex, bForcePassenger, bAllowFlyersAndWaterDinos); }

    void AddStructure(APrimalStructure* Structure, FVector RelLoc, FRotator RelRot, FName BoneName) { NativeCall<void, APrimalStructure*, FVector, FRotator, FName>(this, "APrimalDinoCharacter.AddStructure", Structure, RelLoc, RelRot, BoneName); }

    bool AddToMeleeSwingHurtList(AActor* AnActor) { return NativeCall<bool, AActor*>(this, "APrimalDinoCharacter.AddToMeleeSwingHurtList", AnActor); }

    void AddedImprintingQuality_Implementation(float Amount) { NativeCall<void, float>(this, "APrimalDinoCharacter.AddedImprintingQuality_Implementation", Amount); }

    void AdjustDamage(float* Damage, FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { NativeCall<void, float*, FDamageEvent*, AController*, AActor*>(this, "APrimalDinoCharacter.AdjustDamage", Damage, DamageEvent, EventInstigator, DamageCauser); }

    int AllowBolaBuffBy_Implementation(TSubclassOf<APrimalBuff> BuffClass, AActor* DamageCauser) { return NativeCall<int, TSubclassOf<APrimalBuff>, AActor*>(this, "APrimalDinoCharacter.AllowBolaBuffBy_Implementation", BuffClass, DamageCauser); }

    bool AllowCarryCharacter(APrimalCharacter* CanCarryPawn) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalDinoCharacter.AllowCarryCharacter", CanCarryPawn); }

    bool AllowEquippingItemType(EPrimalEquipmentType::Type equipmentType) { return NativeCall<bool, EPrimalEquipmentType::Type>(this, "APrimalDinoCharacter.AllowEquippingItemType", equipmentType); }

    bool AllowExtendedCraftingFunctionality() { return NativeCall<bool>(this, "APrimalDinoCharacter.AllowExtendedCraftingFunctionality"); }

    bool AllowFallDamage() { return NativeCall<bool>(this, "APrimalDinoCharacter.AllowFallDamage"); }

    bool AllowHurtAnimation() { return NativeCall<bool>(this, "APrimalDinoCharacter.AllowHurtAnimation"); }

    bool AllowIKFreeze() { return NativeCall<bool>(this, "APrimalDinoCharacter.AllowIKFreeze"); }

    bool AllowMountedWeaponry(bool bIgnoreCurrentWeapon, bool bWeaponForcesMountedWeaponry) { return NativeCall<bool, bool, bool>(this, "APrimalDinoCharacter.AllowMountedWeaponry", bIgnoreCurrentWeapon, bWeaponForcesMountedWeaponry); }

    bool AllowMovementMode(EMovementMode NewMovementMode, char NewCustomMode) { return NativeCall<bool, EMovementMode, char>(this, "APrimalDinoCharacter.AllowMovementMode", NewMovementMode, NewCustomMode); }

    bool AllowNewEggAtLocation(FVector* AtLocation) { return NativeCall<bool, FVector*>(this, "APrimalDinoCharacter.AllowNewEggAtLocation", AtLocation); }

    bool AllowPenetrationCheck(AActor* OtherActor) { return NativeCall<bool, AActor*>(this, "APrimalDinoCharacter.AllowPenetrationCheck", OtherActor); }

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

    bool AllowTickPhysics() { return NativeCall<bool>(this, "APrimalDinoCharacter.AllowTickPhysics"); }

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

    bool AllowZoneAutoKill() { return NativeCall<bool>(this, "APrimalDinoCharacter.AllowZoneAutoKill"); }

    void ApplyBoneModifiers(bool bForce) { NativeCall<void, bool>(this, "APrimalDinoCharacter.ApplyBoneModifiers", bForce); }

    void ApplyDamageMomentum(float DamageTaken, FDamageEvent* DamageEvent, APawn* PawnInstigator, AActor* DamageCauser) { NativeCall<void, float, FDamageEvent*, APawn*, AActor*>(this, "APrimalDinoCharacter.ApplyDamageMomentum", DamageTaken, DamageEvent, PawnInstigator, DamageCauser); }

    void ApplyGestationBoneModifiers() { NativeCall<void>(this, "APrimalDinoCharacter.ApplyGestationBoneModifiers"); }

    void ApplyRidingAttackExtraVelocity() { NativeCall<void>(this, "APrimalDinoCharacter.ApplyRidingAttackExtraVelocity"); }

    bool AreSpawnerSublevelsLoaded() { return NativeCall<bool>(this, "APrimalDinoCharacter.AreSpawnerSublevelsLoaded"); }

    void AutoDrag() { NativeCall<void>(this, "APrimalDinoCharacter.AutoDrag"); }

    void AutoTame() { NativeCall<void>(this, "APrimalDinoCharacter.AutoTame"); }

    AShooterCharacter* BPConsumeInventoryFoodItem(UPrimalItem* foodItem, bool bConsumeEntireStack) { return NativeCall<AShooterCharacter*, UPrimalItem*, bool>(this, "APrimalDinoCharacter.BPConsumeInventoryFoodItem", foodItem, bConsumeEntireStack); }

    bool BPIsTamed() { return NativeCall<bool>(this, "APrimalDinoCharacter.BPIsTamed"); }

    void BPNotifyNameEditText(AShooterPlayerController* ForPC) { NativeCall<void, AShooterPlayerController*>(this, "APrimalDinoCharacter.BPNotifyNameEditText", ForPC); }

    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* 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); }

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

    TSubclassOf<UDamageType>* BlueprintOverrideHarvestDamageType_Implementation(TSubclassOf<UDamageType>* result, float* OutHarvestDamageMultiplier) { return NativeCall<TSubclassOf<UDamageType>*, TSubclassOf<UDamageType>*, float*>(this, "APrimalDinoCharacter.BlueprintOverrideHarvestDamageType_Implementation", result, OutHarvestDamageMultiplier); }

    void BrakeDinoBP(float Val) { NativeCall<void, float>(this, "APrimalDinoCharacter.BrakeDinoBP", Val); }

    void CalcCapsuleHalfHeight() { NativeCall<void>(this, "APrimalDinoCharacter.CalcCapsuleHalfHeight"); }

    bool CanAttack(int AttackIndex) { return NativeCall<bool, int>(this, "APrimalDinoCharacter.CanAttack", AttackIndex); }

    bool CanBeCarried(APrimalCharacter* ByCarrier) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalDinoCharacter.CanBeCarried", ByCarrier); }

    bool CanCarryCharacter(APrimalCharacter* CanCarryPawn) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalDinoCharacter.CanCarryCharacter", CanCarryPawn); }

    bool CanDragCharacter(APrimalCharacter* Character) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalDinoCharacter.CanDragCharacter", Character); }

    bool CanFly() { return NativeCall<bool>(this, "APrimalDinoCharacter.CanFly"); }

    bool CanMount(APrimalCharacter* aCharacter) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalDinoCharacter.CanMount", aCharacter); }

    bool CanOrder(APrimalCharacter* FromCharacter, bool bBuildingStructures) { return NativeCall<bool, APrimalCharacter*, bool>(this, "APrimalDinoCharacter.CanOrder", FromCharacter, bBuildingStructures); }

    bool CanReceiveMoveToCommands(AShooterCharacter* FromPlayer) { return NativeCall<bool, AShooterCharacter*>(this, "APrimalDinoCharacter.CanReceiveMoveToCommands", FromPlayer); }

    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 CanTakePassenger(APrimalCharacter* Character, int PassengerSeatIndex, bool bForcePassenger, bool bAllowFlyersAndWaterDinos) { return NativeCall<bool, APrimalCharacter*, int, bool, bool>(this, "APrimalDinoCharacter.CanTakePassenger", Character, PassengerSeatIndex, bForcePassenger, bAllowFlyersAndWaterDinos); }

    bool CanTame(AShooterPlayerController* ForPC, bool bIgnoreMaxTamedDinos, bool bAbsoluteForceTame) { return NativeCall<bool, AShooterPlayerController*, bool, bool>(this, "APrimalDinoCharacter.CanTame", ForPC, bIgnoreMaxTamedDinos, bAbsoluteForceTame); }

    bool CanTarget(ITargetableInterface* Victim) { return NativeCall<bool, ITargetableInterface*>(this, "APrimalDinoCharacter.CanTarget", Victim); }

    bool CarryCharacter(APrimalCharacter* character, bool byPassCanCarryCheck) { return NativeCall<bool, APrimalCharacter*, bool>(this, "APrimalDinoCharacter.CarryCharacter", character, byPassCanCarryCheck); }

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

    void CheckAndHandleBasedPlayersBeingPushedThroughWalls() { NativeCall<void>(this, "APrimalDinoCharacter.CheckAndHandleBasedPlayersBeingPushedThroughWalls"); }

    void CheckForTamedFoodConsumption() { NativeCall<void>(this, "APrimalDinoCharacter.CheckForTamedFoodConsumption"); }

    void CheckForWildAmbientHarvesting() { NativeCall<void>(this, "APrimalDinoCharacter.CheckForWildAmbientHarvesting"); }

    bool CheckLocalPassengers() { return NativeCall<bool>(this, "APrimalDinoCharacter.CheckLocalPassengers"); }

    void ClearAllSaddleStructures() { NativeCall<void>(this, "APrimalDinoCharacter.ClearAllSaddleStructures"); }

    void ClearCarriedCharacter(bool fromCarriedCharacter, bool bCancelAnyCarryBuffs) { NativeCall<void, bool, bool>(this, "APrimalDinoCharacter.ClearCarriedCharacter", fromCarriedCharacter, bCancelAnyCarryBuffs); }

    void ClearCarryingDino(bool bFromDino, bool bCancelAnyCarryBuffs) { NativeCall<void, bool, bool>(this, "APrimalDinoCharacter.ClearCarryingDino", bFromDino, bCancelAnyCarryBuffs); }

    void ClearCharacterAIMovement() { NativeCall<void>(this, "APrimalDinoCharacter.ClearCharacterAIMovement"); }

    void ClearMountCharacter(bool bFromMountCharacter) { NativeCall<void, bool>(this, "APrimalDinoCharacter.ClearMountCharacter", bFromMountCharacter); }

    void ClearPassengers() { NativeCall<void>(this, "APrimalDinoCharacter.ClearPassengers"); }

    void ClearRider(bool FromRider, bool bCancelForceLand, bool SpawnDinoDefaultController, int OverrideUnboardDirection) { NativeCall<void, bool, bool, bool, int>(this, "APrimalDinoCharacter.ClearRider", FromRider, bCancelForceLand, SpawnDinoDefaultController, OverrideUnboardDirection); }

    void ClearRidingDinoAsPassenger(bool bFromDino) { NativeCall<void, bool>(this, "APrimalDinoCharacter.ClearRidingDinoAsPassenger", bFromDino); }

    void ClientInterruptLanding_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ClientInterruptLanding_Implementation"); }

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

    void ClientShouldNotifyLanded_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ClientShouldNotifyLanded_Implementation"); }

    void ClientStartLanding_Implementation(FVector loc) { NativeCall<void, FVector>(this, "APrimalDinoCharacter.ClientStartLanding_Implementation", loc); }

    AShooterCharacter* ConsumeInventoryFoodItem(UPrimalItem* foodItem, float* AffinityIncrease, bool bDontDecrementItem, float* FoodIncrease, float FoodAmountMultiplier, bool bConsumeEntireStack, int FoodItemQuantity) { return NativeCall<AShooterCharacter*, UPrimalItem*, float*, bool, float*, float, bool, int>(this, "APrimalDinoCharacter.ConsumeInventoryFoodItem", foodItem, AffinityIncrease, bDontDecrementItem, FoodIncrease, FoodAmountMultiplier, bConsumeEntireStack, FoodItemQuantity); }

    void ControllerLeavingGame(AShooterPlayerController* theController) { NativeCall<void, AShooterPlayerController*>(this, "APrimalDinoCharacter.ControllerLeavingGame", theController); }

    ADroppedItem* CreateCloneFertilizedEgg(FVector AtLoc, FRotator AtRot, TSubclassOf<ADroppedItem> DroppedItemTemplateOverride) { return NativeCall<ADroppedItem*, FVector, FRotator, TSubclassOf<ADroppedItem>>(this, "APrimalDinoCharacter.CreateCloneFertilizedEgg", AtLoc, AtRot, DroppedItemTemplateOverride); }

    void CycleAttackWeightsForAttackAtIndex(int attackIndex) { NativeCall<void, int>(this, "APrimalDinoCharacter.CycleAttackWeightsForAttackAtIndex", attackIndex); }

    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); }

    void DeathHarvestingFadeOut_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.DeathHarvestingFadeOut_Implementation"); }

    void DestroyController() { NativeCall<void>(this, "APrimalDinoCharacter.DestroyController"); }

    void Destroyed() { NativeCall<void>(this, "APrimalDinoCharacter.Destroyed"); }

    void DidLand() { NativeCall<void>(this, "APrimalDinoCharacter.DidLand"); }

    bool Die(float KillingDamage, FDamageEvent* DamageEvent, AController* Killer, AActor* DamageCauser) { return NativeCall<bool, float, FDamageEvent*, AController*, AActor*>(this, "APrimalDinoCharacter.Die", KillingDamage, DamageEvent, Killer, DamageCauser); }

    void DinoKillerTransferItemsToInventory(UPrimalInventoryComponent* FromInventory) { NativeCall<void, UPrimalInventoryComponent*>(this, "APrimalDinoCharacter.DinoKillerTransferItemsToInventory", FromInventory); }

    bool DisableHarvesting() { return NativeCall<bool>(this, "APrimalDinoCharacter.DisableHarvesting"); }

    bool DoAttack(int AttackIndex, bool bSetCurrentAttack) { return NativeCall<bool, int, bool>(this, "APrimalDinoCharacter.DoAttack", AttackIndex, bSetCurrentAttack); }

    void DoMate(APrimalDinoCharacter* WithMate) { NativeCall<void, APrimalDinoCharacter*>(this, "APrimalDinoCharacter.DoMate", WithMate); }

    void DoNeuter_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.DoNeuter_Implementation"); }

    bool DoesDinoHaveBasedPawns(bool bRequireActivePawns) { return NativeCall<bool, bool>(this, "APrimalDinoCharacter.DoesDinoHaveBasedPawns", bRequireActivePawns); }

    void DrawDinoFloatingHUD(AShooterHUD* HUD, bool bDrawDinoOrderIcon) { NativeCall<void, AShooterHUD*, bool>(this, "APrimalDinoCharacter.DrawDinoFloatingHUD", HUD, bDrawDinoOrderIcon); }

    void DrawFloatingHUD(AShooterHUD* HUD) { NativeCall<void, AShooterHUD*>(this, "APrimalDinoCharacter.DrawFloatingHUD", HUD); }

    void DrawHUD(AShooterHUD* HUD) { NativeCall<void, AShooterHUD*>(this, "APrimalDinoCharacter.DrawHUD", HUD); }

    void ElevateDinoBP(float Val) { NativeCall<void, float>(this, "APrimalDinoCharacter.ElevateDinoBP", Val); }

    void EmitPoop() { NativeCall<void>(this, "APrimalDinoCharacter.EmitPoop"); }

    void EndCharging(bool bForce) { NativeCall<void, bool>(this, "APrimalDinoCharacter.EndCharging", bForce); }

    void FaceRotation(FRotator NewControlRotation, float DeltaTime, bool bFromController) { NativeCall<void, FRotator, float, bool>(this, "APrimalDinoCharacter.FaceRotation", NewControlRotation, DeltaTime, bFromController); }

    void FedWakingTameDino_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.FedWakingTameDino_Implementation"); }

    void FinalLoadedFromSaveGame() { NativeCall<void>(this, "APrimalDinoCharacter.FinalLoadedFromSaveGame"); }

    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); }

    AShooterCharacter* FindFirstFoodItemPlayerCharacter() { return NativeCall<AShooterCharacter*>(this, "APrimalDinoCharacter.FindFirstFoodItemPlayerCharacter"); }

    void FinishedLanding() { NativeCall<void>(this, "APrimalDinoCharacter.FinishedLanding"); }

    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); }

    void FireProjectileLocal(FVector Origin, FVector_NetQuantizeNormal ShootDir, bool bScaleProjDamageByDinoDamage) { NativeCall<void, FVector, FVector_NetQuantizeNormal, bool>(this, "APrimalDinoCharacter.FireProjectileLocal", Origin, ShootDir, bScaleProjDamageByDinoDamage); }

    void FireProjectile_Implementation(FVector Origin, FVector_NetQuantizeNormal ShootDir, bool bScaleProjDamageByDinoDamage) { NativeCall<void, FVector, FVector_NetQuantizeNormal, bool>(this, "APrimalDinoCharacter.FireProjectile_Implementation", Origin, ShootDir, bScaleProjDamageByDinoDamage); }

    bool ForceAllowAccelerationRotationWhenFalling() { return NativeCall<bool>(this, "APrimalDinoCharacter.ForceAllowAccelerationRotationWhenFalling"); }

    bool ForceAllowBackwardsMovement() { return NativeCall<bool>(this, "APrimalDinoCharacter.ForceAllowBackwardsMovement"); }

    void ForceClearRider() { NativeCall<void>(this, "APrimalDinoCharacter.ForceClearRider"); }

    void ForceRefreshTransform() { NativeCall<void>(this, "APrimalDinoCharacter.ForceRefreshTransform"); }

    void ForceUpdateColorSets_Implementation(int ColorRegion, int ColorSet) { NativeCall<void, int, int>(this, "APrimalDinoCharacter.ForceUpdateColorSets_Implementation", ColorRegion, ColorSet); }

    float GetAIFollowStoppingDistanceMultiplier() { return NativeCall<float>(this, "APrimalDinoCharacter.GetAIFollowStoppingDistanceMultiplier"); }

    float GetAIFollowStoppingDistanceOffset() { return NativeCall<float>(this, "APrimalDinoCharacter.GetAIFollowStoppingDistanceOffset"); }

    float GetAffinityIncreaseForFoodItem(UPrimalItem* foodItem) { return NativeCall<float, UPrimalItem*>(this, "APrimalDinoCharacter.GetAffinityIncreaseForFoodItem", foodItem); }

    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* GetAimOffsetsForTarget(FRotator* result, AActor* AimTarget, float DeltaTime, bool bOverrideYawLimits, FRotator* RootRotOffset, float* RootYawSpeed, float MaxYawAimClamp, FVector* RootLocOffset, FName SocketOverrideName) { return NativeCall<FRotator*, FRotator*, AActor*, float, bool, FRotator*, float*, float, FVector*, FName>(this, "APrimalDinoCharacter.GetAimOffsetsForTarget", result, AimTarget, DeltaTime, bOverrideYawLimits, RootRotOffset, RootYawSpeed, MaxYawAimClamp, RootLocOffset, SocketOverrideName); }

    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); }

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

    APrimalStructureExplosive* GetAttachedExplosive() { return NativeCall<APrimalStructureExplosive*>(this, "APrimalDinoCharacter.GetAttachedExplosive"); }

    float GetAttachedSoundPitchMultiplier() { return NativeCall<float>(this, "APrimalDinoCharacter.GetAttachedSoundPitchMultiplier"); }

    float GetAttachedSoundVolumeMultiplier() { return NativeCall<float>(this, "APrimalDinoCharacter.GetAttachedSoundVolumeMultiplier"); }

    float GetAttackRangeOffset() { return NativeCall<float>(this, "APrimalDinoCharacter.GetAttackRangeOffset"); }

    void GetAttackTargets(AActor** attackActor, FVector* attackLoc) { NativeCall<void, AActor**, FVector*>(this, "APrimalDinoCharacter.GetAttackTargets", attackActor, attackLoc); }

    TSubclassOf<UPrimalItem>* GetBabyCuddleFood(TSubclassOf<UPrimalItem>* result) { return NativeCall<TSubclassOf<UPrimalItem>*, TSubclassOf<UPrimalItem>*>(this, "APrimalDinoCharacter.GetBabyCuddleFood", result); }

    float GetBaseDragWeight() { return NativeCall<float>(this, "APrimalDinoCharacter.GetBaseDragWeight"); }

    float GetBaseTargetingDesire(ITargetableInterface* Attacker) { return NativeCall<float, ITargetableInterface*>(this, "APrimalDinoCharacter.GetBaseTargetingDesire", Attacker); }

    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); }

    float GetCarryingSocketYaw(bool RefreshBones) { return NativeCall<float, bool>(this, "APrimalDinoCharacter.GetCarryingSocketYaw", RefreshBones); }

    float GetCorpseLifespan() { return NativeCall<float>(this, "APrimalDinoCharacter.GetCorpseLifespan"); }

    float GetCorpseTargetingMultiplier() { return NativeCall<float>(this, "APrimalDinoCharacter.GetCorpseTargetingMultiplier"); }

    TArray<FName>* GetCurrentBiomeTags(TArray<FName>* result) { return NativeCall<TArray<FName>*, TArray<FName>*>(this, "APrimalDinoCharacter.GetCurrentBiomeTags", result); }

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

    TArray<APawn*>* GetDinoBasedPawns(TArray<APawn*>* result, USceneComponent* OnComponent, bool bOnlyActivePawns) { return NativeCall<TArray<APawn*>*, TArray<APawn*>*, USceneComponent*, bool>(this, "APrimalDinoCharacter.GetDinoBasedPawns", result, OnComponent, bOnlyActivePawns); }

    FLinearColor* GetDinoColor(FLinearColor* result, int ColorRegionIndex) { return NativeCall<FLinearColor*, FLinearColor*, int>(this, "APrimalDinoCharacter.GetDinoColor", result, ColorRegionIndex); }

    long double GetDinoDeathTime() { return NativeCall<long double>(this, "APrimalDinoCharacter.GetDinoDeathTime"); }

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

    UAnimMontage* GetDinoLevelUpAnimation() { return NativeCall<UAnimMontage*>(this, "APrimalDinoCharacter.GetDinoLevelUpAnimation"); }

    TArray<AActor*>* GetDinoPlatformCollisionIgnoreActors(TArray<AActor*>* result) { return NativeCall<TArray<AActor*>*, TArray<AActor*>*>(this, "APrimalDinoCharacter.GetDinoPlatformCollisionIgnoreActors", result); }

    USoundBase* GetDinoTameSound_Implementation() { return NativeCall<USoundBase*>(this, "APrimalDinoCharacter.GetDinoTameSound_Implementation"); }

    FVector* GetDinoVelocity(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APrimalDinoCharacter.GetDinoVelocity", result); }

    FString* GetEntryDescription(FString* result) { return NativeCall<FString*, FString*>(this, "APrimalDinoCharacter.GetEntryDescription", 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); }

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

    int GetExtraFoodItemEffectivenessMultipliersIndex(UPrimalItem* foodItem) { return NativeCall<int, UPrimalItem*>(this, "APrimalDinoCharacter.GetExtraFoodItemEffectivenessMultipliersIndex", foodItem); }

    TSubclassOf<UPrimalItem>* GetFirstAffinityFoodItemClass(TSubclassOf<UPrimalItem>* result) { return NativeCall<TSubclassOf<UPrimalItem>*, TSubclassOf<UPrimalItem>*>(this, "APrimalDinoCharacter.GetFirstAffinityFoodItemClass", result); }

    FVector* GetFloatingHUDLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APrimalDinoCharacter.GetFloatingHUDLocation", result); }

    int GetFoodItemEffectivenessMultipliersIndex(UPrimalItem* foodItem) { return NativeCall<int, UPrimalItem*>(this, "APrimalDinoCharacter.GetFoodItemEffectivenessMultipliersIndex", foodItem); }

    long double GetForceClaimTime() { return NativeCall<long double>(this, "APrimalDinoCharacter.GetForceClaimTime"); }

    bool GetForceTickPose() { return NativeCall<bool>(this, "APrimalDinoCharacter.GetForceTickPose"); }

    float GetGestationTimeRemaining() { return NativeCall<float>(this, "APrimalDinoCharacter.GetGestationTimeRemaining"); }

    float GetGravityZScale() { return NativeCall<float>(this, "APrimalDinoCharacter.GetGravityZScale"); }

    float GetHealthPercentage() { return NativeCall<float>(this, "APrimalDinoCharacter.GetHealthPercentage"); }

    FVector* GetInterpolatedLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APrimalDinoCharacter.GetInterpolatedLocation", result); }

    FVector* GetLandingLocation(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APrimalDinoCharacter.GetLandingLocation", result); }

    float GetLeveledDamageMultiplier() { return NativeCall<float>(this, "APrimalDinoCharacter.GetLeveledDamageMultiplier"); }

    void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>* OutLifetimeProps) { NativeCall<void, TArray<FLifetimeProperty>*>(this, "APrimalDinoCharacter.GetLifetimeReplicatedProps", OutLifetimeProps); }

    float GetMaxFloatingHUDRange() { return NativeCall<float>(this, "APrimalDinoCharacter.GetMaxFloatingHUDRange"); }

    float GetMaxSpeedModifier() { return NativeCall<float>(this, "APrimalDinoCharacter.GetMaxSpeedModifier"); }

    float GetMyCurrentAmbientTemperature() { return NativeCall<float>(this, "APrimalDinoCharacter.GetMyCurrentAmbientTemperature"); }

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

    int GetNumPassengerSeats(bool bOnlyManualPassengerSeats) { return NativeCall<int, bool>(this, "APrimalDinoCharacter.GetNumPassengerSeats", bOnlyManualPassengerSeats); }

    UObject* GetUObjectInterfaceDataListEntryInterface() { return NativeCall<UObject*>(this, "APrimalDinoCharacter.GetUObjectInterfaceDataListEntryInterface"); }

    int GetOriginalTargetingTeam() { return NativeCall<int>(this, "APrimalDinoCharacter.GetOriginalTargetingTeam"); }

    AActor* GetOtherActorToIgnore() { return NativeCall<AActor*>(this, "APrimalDinoCharacter.GetOtherActorToIgnore"); }

    APrimalCharacter* GetPassengerPerSeat(int SeatIndex) { return NativeCall<APrimalCharacter*, int>(this, "APrimalDinoCharacter.GetPassengerPerSeat", SeatIndex); }

    FSaddlePassengerSeatDefinition* GetPassengerSeatDefinition(char SeatIndex) { return NativeCall<FSaddlePassengerSeatDefinition*, char>(this, "APrimalDinoCharacter.GetPassengerSeatDefinition", SeatIndex); }

    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 GetRandomBaseLevel() { return NativeCall<int>(this, "APrimalDinoCharacter.GetRandomBaseLevel"); }

    int GetRequiredWakingTameFoodItemQuanity(UPrimalItem* FoodItem) { return NativeCall<int, UPrimalItem*>(this, "APrimalDinoCharacter.GetRequiredWakingTameFoodItemQuanity", FoodItem); }

    void GetRidingCarryingIgnoreList(TArray<AActor*>* IgnoreList) { NativeCall<void, TArray<AActor*>*>(this, "APrimalDinoCharacter.GetRidingCarryingIgnoreList", IgnoreList); }

    float GetRotationRateModifier() { return NativeCall<float>(this, "APrimalDinoCharacter.GetRotationRateModifier"); }

    float GetRunningSpeedModifier(bool bIsForDefaultSpeed) { return NativeCall<float, bool>(this, "APrimalDinoCharacter.GetRunningSpeedModifier", bIsForDefaultSpeed); }

    float GetSaddleStructureMaximumFoundationSupport2DBuildDistance(APrimalStructure* theStructure) { return NativeCall<float, APrimalStructure*>(this, "APrimalDinoCharacter.GetSaddleStructureMaximumFoundationSupport2DBuildDistance", theStructure); }

    int GetSeatIndexForPassenger(APrimalCharacter* PassengerChar) { return NativeCall<int, APrimalCharacter*>(this, "APrimalDinoCharacter.GetSeatIndexForPassenger", PassengerChar); }

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

    FVector* GetSocketLocationTemp(FVector* result, FName SocketName) { return NativeCall<FVector*, FVector*, FName>(this, "APrimalDinoCharacter.GetSocketLocationTemp", result, SocketName); }

    float GetSpeedModifier() { return NativeCall<float>(this, "APrimalDinoCharacter.GetSpeedModifier"); }

    int GetTamedDinoCountCost() { return NativeCall<int>(this, "APrimalDinoCharacter.GetTamedDinoCountCost"); }

    AActor* GetTamedFollowTarget() { return NativeCall<AActor*>(this, "APrimalDinoCharacter.GetTamedFollowTarget"); }

    float GetTargetingDesirability(ITargetableInterface* Attacker) { return NativeCall<float, ITargetableInterface*>(this, "APrimalDinoCharacter.GetTargetingDesirability", Attacker); }

    AActor* GetTargetingPlayer() { return NativeCall<AActor*>(this, "APrimalDinoCharacter.GetTargetingPlayer"); }

    TArray<AActor*>* GetTracingIgnoreActors() { return NativeCall<TArray<AActor*>*>(this, "APrimalDinoCharacter.GetTracingIgnoreActors"); }

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

    char GetWiegthedAttack(float distance, float attackRangeOffset, AActor* OtherTarget) { return NativeCall<char, float, float, AActor*>(this, "APrimalDinoCharacter.GetWiegthedAttack", distance, attackRangeOffset, OtherTarget); }

    void GiveDeathDossier() { NativeCall<void>(this, "APrimalDinoCharacter.GiveDeathDossier"); }

    void HandleUnstasised(bool bWasFromHibernation) { NativeCall<void, bool>(this, "APrimalDinoCharacter.HandleUnstasised", bWasFromHibernation); }

    bool HasReachedDestination(FVector* Goal) { return NativeCall<bool, FVector*>(this, "APrimalDinoCharacter.HasReachedDestination", Goal); }

    void ImprintOnPlayerTarget(AShooterPlayerController* ForPC, bool bIgnoreMaxTameLimit) { NativeCall<void, AShooterPlayerController*, bool>(this, "APrimalDinoCharacter.ImprintOnPlayerTarget", ForPC, bIgnoreMaxTameLimit); }

    void IncrementImprintingQuality() { NativeCall<void>(this, "APrimalDinoCharacter.IncrementImprintingQuality"); }

    void IncrementNumTamedDinos() { NativeCall<void>(this, "APrimalDinoCharacter.IncrementNumTamedDinos"); }

    void InitDownloadedTamedDino(AShooterPlayerController* TamerController, int AltTeam) { NativeCall<void, AShooterPlayerController*, int>(this, "APrimalDinoCharacter.InitDownloadedTamedDino", TamerController, AltTeam); }

    bool InitializeForReplicatedBasing() { return NativeCall<bool>(this, "APrimalDinoCharacter.InitializeForReplicatedBasing"); }

    void InterruptLanding() { NativeCall<void>(this, "APrimalDinoCharacter.InterruptLanding"); }

    int IsActorTickAllowed() { return NativeCall<int>(this, "APrimalDinoCharacter.IsActorTickAllowed"); }

    bool IsAttacking() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsAttacking"); }

    bool IsCurrentAttackStopsMovement() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsCurrentAttackStopsMovement"); }

    bool IsCurrentlyPlayingAttackAnimation() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsCurrentlyPlayingAttackAnimation"); }

    bool IsDamageOccludedByStructures(AActor* DamageCauser) { return NativeCall<bool, AActor*>(this, "APrimalDinoCharacter.IsDamageOccludedByStructures", DamageCauser); }

    bool IsFemale() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsFemale"); }

    bool IsFleeing() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsFleeing"); }

    bool IsImprintPlayer(AShooterCharacter* ForChar) { return NativeCall<bool, AShooterCharacter*>(this, "APrimalDinoCharacter.IsImprintPlayer", ForChar); }

    bool IsInMatingBiome() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsInMatingBiome"); }

    bool IsNearFeed(AShooterPlayerState* ForPlayer) { return NativeCall<bool, AShooterPlayerState*>(this, "APrimalDinoCharacter.IsNearFeed", ForPlayer); }

    bool IsPrimalCharFriendly(APrimalCharacter* primalChar) { return NativeCall<bool, APrimalCharacter*>(this, "APrimalDinoCharacter.IsPrimalCharFriendly", primalChar); }

    bool IsShip() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsShip"); }

    bool IsTaming() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsTaming"); }

    bool IsUpdatingComponentTransforms(USceneComponent* InSceneComponent) { return NativeCall<bool, USceneComponent*>(this, "APrimalDinoCharacter.IsUpdatingComponentTransforms", InSceneComponent); }

    bool IsUsingBolaSleepingAnimations() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsUsingBolaSleepingAnimations"); }

    bool IsValidForStatusUpdate() { return NativeCall<bool>(this, "APrimalDinoCharacter.IsValidForStatusUpdate"); }

    int IsWithinBreedingTemperature() { return NativeCall<int>(this, "APrimalDinoCharacter.IsWithinBreedingTemperature"); }

    void KeepFlight(float ForDuration) { NativeCall<void, float>(this, "APrimalDinoCharacter.KeepFlight", ForDuration); }

    void KeepFlightTimer() { NativeCall<void>(this, "APrimalDinoCharacter.KeepFlightTimer"); }

    void LinkedSupplyCrateDestroyed(APrimalStructureItemContainer_SupplyCrate* aCrate) { NativeCall<void, APrimalStructureItemContainer_SupplyCrate*>(this, "APrimalDinoCharacter.LinkedSupplyCrateDestroyed", aCrate); }

    void LowerDinoBP(float Val) { NativeCall<void, float>(this, "APrimalDinoCharacter.LowerDinoBP", Val); }

    void ModifyDesiredRotation(FRotator* InDesiredRotation) { NativeCall<void, FRotator*>(this, "APrimalDinoCharacter.ModifyDesiredRotation", InDesiredRotation); }

    bool ModifyInputAcceleration(FVector* InputAcceleration) { return NativeCall<bool, FVector*>(this, "APrimalDinoCharacter.ModifyInputAcceleration", InputAcceleration); }

    void MoveBlockedBy(FHitResult* Impact) { NativeCall<void, FHitResult*>(this, "APrimalDinoCharacter.MoveBlockedBy", Impact); }

    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); }

    bool NPC_FindNearbyUsableStructures(TArray<AActor*>* FoundStructures) { return NativeCall<bool, TArray<AActor*>*>(this, "APrimalDinoCharacter.NPC_FindNearbyUsableStructures", FoundStructures); }

    APrimalStructure* NPC_GetClosestUsableStructure() { return NativeCall<APrimalStructure*>(this, "APrimalDinoCharacter.NPC_GetClosestUsableStructure"); }

    void NetUpdateDinoNameStrings_Implementation(FString* NewTamerString, FString* NewTamedName) { NativeCall<void, FString*, FString*>(this, "APrimalDinoCharacter.NetUpdateDinoNameStrings_Implementation", NewTamerString, NewTamedName); }

    void NetUpdateDinoOwnerData_Implementation(FString* NewOwningPlayerName, int NewOwningPlayerID) { NativeCall<void, FString*, int>(this, "APrimalDinoCharacter.NetUpdateDinoOwnerData_Implementation", NewOwningPlayerName, NewOwningPlayerID); }

    void NotifyBumpedPawn(APawn* BumpedPawn) { NativeCall<void, APawn*>(this, "APrimalDinoCharacter.NotifyBumpedPawn", BumpedPawn); }

    void NotifyBumpedStructure(AActor* BumpedStructure) { NativeCall<void, AActor*>(this, "APrimalDinoCharacter.NotifyBumpedStructure", BumpedStructure); }

    void NotifyItemAdded(UPrimalItem* anItem, bool bEquipItem) { NativeCall<void, UPrimalItem*, bool>(this, "APrimalDinoCharacter.NotifyItemAdded", anItem, bEquipItem); }

    void NotifyItemRemoved(UPrimalItem* anItem) { NativeCall<void, UPrimalItem*>(this, "APrimalDinoCharacter.NotifyItemRemoved", anItem); }

    void OffBrake() { NativeCall<void>(this, "APrimalDinoCharacter.OffBrake"); }

    void OnBrake() { NativeCall<void>(this, "APrimalDinoCharacter.OnBrake"); }

    void OnClientReceivedTransformAfterPairingNetGUID(FVector* Loc, FRotator* Rot) { NativeCall<void, FVector*, FRotator*>(this, "APrimalDinoCharacter.OnClientReceivedTransformAfterPairingNetGUID", Loc, Rot); }

    void OnControllerInitiatedAttack(int AttackIndex) { NativeCall<void, int>(this, "APrimalDinoCharacter.OnControllerInitiatedAttack", AttackIndex); }

    void OnDeserializedByGame(EOnDesrializationType::Type DeserializationType) { NativeCall<void, EOnDesrializationType::Type>(this, "APrimalDinoCharacter.OnDeserializedByGame", DeserializationType); }

    void OnElevateDino(float Val) { NativeCall<void, float>(this, "APrimalDinoCharacter.OnElevateDino", Val); }

    void OnLowerDino(float Val) { NativeCall<void, float>(this, "APrimalDinoCharacter.OnLowerDino", Val); }

    void OnNPCStartedAttack_Implementation(int AttackIndex, int AnimationIndex, bool bIsAltAnim, AActor* MyTarget) { NativeCall<void, int, int, bool, AActor*>(this, "APrimalDinoCharacter.OnNPCStartedAttack_Implementation", AttackIndex, AnimationIndex, bIsAltAnim, MyTarget); }

    void OnPressCrouch() { NativeCall<void>(this, "APrimalDinoCharacter.OnPressCrouch"); }

    void OnPressDrag() { NativeCall<void>(this, "APrimalDinoCharacter.OnPressDrag"); }

    void OnPressProne() { NativeCall<void>(this, "APrimalDinoCharacter.OnPressProne"); }

    void OnPressReload() { NativeCall<void>(this, "APrimalDinoCharacter.OnPressReload"); }

    void OnPrimalCharacterSleeped() { NativeCall<void>(this, "APrimalDinoCharacter.OnPrimalCharacterSleeped"); }

    void OnPrimalCharacterUnsleeped() { NativeCall<void>(this, "APrimalDinoCharacter.OnPrimalCharacterUnsleeped"); }

    void OnRep_CarriedCharacter() { NativeCall<void>(this, "APrimalDinoCharacter.OnRep_CarriedCharacter"); }

    void OnRep_PassengerPerSeat() { NativeCall<void>(this, "APrimalDinoCharacter.OnRep_PassengerPerSeat"); }

    void OnRep_Rider() { NativeCall<void>(this, "APrimalDinoCharacter.OnRep_Rider"); }

    void OnRep_Saddle() { NativeCall<void>(this, "APrimalDinoCharacter.OnRep_Saddle"); }

    void OnRep_bBonesHidden() { NativeCall<void>(this, "APrimalDinoCharacter.OnRep_bBonesHidden"); }

    void OnRep_bIsCharging() { NativeCall<void>(this, "APrimalDinoCharacter.OnRep_bIsCharging"); }

    void OnRep_bIsFlying() { NativeCall<void>(this, "APrimalDinoCharacter.OnRep_bIsFlying"); }

    void OnSaddleStructuresUpdated(APrimalStructure* SaddleStructure, bool bWasRemoved) { NativeCall<void, APrimalStructure*, bool>(this, "APrimalDinoCharacter.OnSaddleStructuresUpdated", SaddleStructure, bWasRemoved); }

    void OnStartFire(bool bFromGamepadRight, int weaponAttackIndex, bool bDoLeftSide, bool bOverrideCurrentAttack) { NativeCall<void, bool, int, bool, bool>(this, "APrimalDinoCharacter.OnStartFire", bFromGamepadRight, weaponAttackIndex, bDoLeftSide, bOverrideCurrentAttack); }

    void OnStartJump() { NativeCall<void>(this, "APrimalDinoCharacter.OnStartJump"); }

    void OnStartTargeting(bool bFromGamepadLeft) { NativeCall<void, bool>(this, "APrimalDinoCharacter.OnStartTargeting", bFromGamepadLeft); }

    void OnStopFire(bool bFromGamepadRight, int weaponAttackIndex) { NativeCall<void, bool, int>(this, "APrimalDinoCharacter.OnStopFire", bFromGamepadRight, weaponAttackIndex); }

    void OnStopTargeting(bool bFromGamepadLeft) { NativeCall<void, bool>(this, "APrimalDinoCharacter.OnStopTargeting", bFromGamepadLeft); }

    bool OverrideForcePreventExitingWater() { return NativeCall<bool>(this, "APrimalDinoCharacter.OverrideForcePreventExitingWater"); }

    void OverrideRandomWanderLocation_Implementation(FVector* originalDestination, FVector* inVec) { NativeCall<void, FVector*, FVector*>(this, "APrimalDinoCharacter.OverrideRandomWanderLocation_Implementation", originalDestination, inVec); }

    void PlayAttackAnimationOfAnimationArray(int AnimationIndex, TArray<UAnimMontage*> attackAnimations) { NativeCall<void, int, TArray<UAnimMontage*>>(this, "APrimalDinoCharacter.PlayAttackAnimationOfAnimationArray", AnimationIndex, attackAnimations); }

    void PlayChargingAnim() { NativeCall<void>(this, "APrimalDinoCharacter.PlayChargingAnim"); }

    void PlayDying(float KillingDamage, FDamageEvent* DamageEvent, APawn* InstigatingPawn, AActor* DamageCauser) { NativeCall<void, float, FDamageEvent*, APawn*, AActor*>(this, "APrimalDinoCharacter.PlayDying", KillingDamage, DamageEvent, InstigatingPawn, DamageCauser); }

    void PlayHardEndChargingShake_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.PlayHardEndChargingShake_Implementation"); }

    void PlayWeightedAttackAnimation() { NativeCall<void>(this, "APrimalDinoCharacter.PlayWeightedAttackAnimation"); }

    bool PlayedAnimationHasAttack() { return NativeCall<bool>(this, "APrimalDinoCharacter.PlayedAnimationHasAttack"); }

    void Poop(bool bForcePoop) { NativeCall<void, bool>(this, "APrimalDinoCharacter.Poop", bForcePoop); }

    void PostInitializeComponents() { NativeCall<void>(this, "APrimalDinoCharacter.PostInitializeComponents"); }

    void PostNetInit() { NativeCall<void>(this, "APrimalDinoCharacter.PostNetInit"); }

    void PostNetReceiveLocationAndRotation() { NativeCall<void>(this, "APrimalDinoCharacter.PostNetReceiveLocationAndRotation"); }

    void PrepareForSaving() { NativeCall<void>(this, "APrimalDinoCharacter.PrepareForSaving"); }

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

    void ProcessEditText(AShooterPlayerController* ForPC, FString* TextToUse, bool checkedBox, unsigned int ExtraID1, unsigned int ExtraID2) { NativeCall<void, AShooterPlayerController*, FString*, bool, unsigned int, unsigned int>(this, "APrimalDinoCharacter.ProcessEditText", ForPC, TextToUse, checkedBox, ExtraID1, ExtraID2); }

    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); }

    void ReceiveAnyDamage_Implementation(float Damage, UDamageType* DamageType, AController* InstigatedBy, AActor* DamageCauser) { NativeCall<void, float, UDamageType*, AController*, AActor*>(this, "APrimalDinoCharacter.ReceiveAnyDamage_Implementation", Damage, DamageType, InstigatedBy, DamageCauser); }

    void RefreshBabyScaling() { NativeCall<void>(this, "APrimalDinoCharacter.RefreshBabyScaling"); }

    void RefreshColorization() { NativeCall<void>(this, "APrimalDinoCharacter.RefreshColorization"); }

    void RegisterAllComponents() { NativeCall<void>(this, "APrimalDinoCharacter.RegisterAllComponents"); }

    void RemoveBasedPawn(AActor* anPawn) { NativeCall<void, AActor*>(this, "APrimalDinoCharacter.RemoveBasedPawn", anPawn); }

    void RemoveDinoReferenceFromLatchingStructure() { NativeCall<void>(this, "APrimalDinoCharacter.RemoveDinoReferenceFromLatchingStructure"); }

    void RemoveFromMeleeSwingHurtList(AActor* AnActor) { NativeCall<void, AActor*>(this, "APrimalDinoCharacter.RemoveFromMeleeSwingHurtList", AnActor); }

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

    void RemovePassenger(APrimalCharacter* Character, bool bFromCharacter, bool bFromPlayerController) { NativeCall<void, APrimalCharacter*, bool, bool>(this, "APrimalDinoCharacter.RemovePassenger", Character, bFromCharacter, bFromPlayerController); }

    void RemoveSaddleAttachment(FItemNetID Id) { NativeCall<void, FItemNetID>(this, "APrimalDinoCharacter.RemoveSaddleAttachment", Id); }

    void RemoveStructure(APrimalStructure* Structure) { NativeCall<void, APrimalStructure*>(this, "APrimalDinoCharacter.RemoveStructure", Structure); }

    void RepairCheckTimer() { NativeCall<void>(this, "APrimalDinoCharacter.RepairCheckTimer"); }

    void ResetCurrentAttackIndex() { NativeCall<void>(this, "APrimalDinoCharacter.ResetCurrentAttackIndex"); }

    void ResetTakingOff() { NativeCall<void>(this, "APrimalDinoCharacter.ResetTakingOff"); }

    void Restart() { NativeCall<void>(this, "APrimalDinoCharacter.Restart"); }

    bool SaddleDinoHasAnyDemolishableStructures() { return NativeCall<bool>(this, "APrimalDinoCharacter.SaddleDinoHasAnyDemolishableStructures"); }

    void SaddledStructureDestroyed(APrimalStructure* theStructure) { NativeCall<void, APrimalStructure*>(this, "APrimalDinoCharacter.SaddledStructureDestroyed", theStructure); }

    void ServerCallAggressive_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerCallAggressive_Implementation"); }

    void ServerCallAttackTarget_Implementation(AActor* TheTarget) { NativeCall<void, AActor*>(this, "APrimalDinoCharacter.ServerCallAttackTarget_Implementation", TheTarget); }

    void ServerCallFollowDistanceCycleOne_Implementation(APrimalDinoCharacter* ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "APrimalDinoCharacter.ServerCallFollowDistanceCycleOne_Implementation", ForDinoChar); }

    void ServerCallFollowOne_Implementation(APrimalDinoCharacter* ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "APrimalDinoCharacter.ServerCallFollowOne_Implementation", ForDinoChar); }

    void ServerCallFollow_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerCallFollow_Implementation"); }

    void ServerCallMoveTo_Implementation(FVector MoveToLoc, AActor* TargetActor) { NativeCall<void, FVector, AActor*>(this, "APrimalDinoCharacter.ServerCallMoveTo_Implementation", MoveToLoc, TargetActor); }

    void ServerCallNeutral_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerCallNeutral_Implementation"); }

    void ServerCallPassive_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerCallPassive_Implementation"); }

    void ServerCallSetAggressive_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerCallSetAggressive_Implementation"); }

    void ServerCallStayOne_Implementation(APrimalDinoCharacter* ForDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "APrimalDinoCharacter.ServerCallStayOne_Implementation", ForDinoChar); }

    void ServerCallStay_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerCallStay_Implementation"); }

    void ServerClearRider_Implementation(int OverrideUnboardDirection) { NativeCall<void, int>(this, "APrimalDinoCharacter.ServerClearRider_Implementation", OverrideUnboardDirection); }

    void ServerFinishedLanding_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerFinishedLanding_Implementation"); }

    void ServerGiveDefaultWeapon_Implementation(bool bOnlyGiveDefaultWeapon) { NativeCall<void, bool>(this, "APrimalDinoCharacter.ServerGiveDefaultWeapon_Implementation", bOnlyGiveDefaultWeapon); }

    void ServerInterruptLanding_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerInterruptLanding_Implementation"); }

    void ServerRequestAttack_Implementation(int attackIndex) { NativeCall<void, int>(this, "APrimalDinoCharacter.ServerRequestAttack_Implementation", attackIndex); }

    void ServerRequestBraking_Implementation(bool bWantsToBrake) { NativeCall<void, bool>(this, "APrimalDinoCharacter.ServerRequestBraking_Implementation", bWantsToBrake); }

    void ServerRequestToggleFlight_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerRequestToggleFlight_Implementation"); }

    void ServerRequestWaterSurfaceJump_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerRequestWaterSurfaceJump_Implementation"); }

    void ServerSetRiderMountedWeaponRotation_Implementation(FRotator InVal) { NativeCall<void, FRotator>(this, "APrimalDinoCharacter.ServerSetRiderMountedWeaponRotation_Implementation", InVal); }

    void ServerSleepingTick() { NativeCall<void>(this, "APrimalDinoCharacter.ServerSleepingTick"); }

    void ServerTamedTick() { NativeCall<void>(this, "APrimalDinoCharacter.ServerTamedTick"); }

    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); }

    void ServerToggleCharging_Implementation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerToggleCharging_Implementation"); }

    void ServerUpdateAttackTargets_Implementation(AActor* AttackTarget, FVector AttackLocation) { NativeCall<void, AActor*, FVector>(this, "APrimalDinoCharacter.ServerUpdateAttackTargets_Implementation", AttackTarget, AttackLocation); }

    void ServerUpdateBabyAge(float overrideAgePercent) { NativeCall<void, float>(this, "APrimalDinoCharacter.ServerUpdateBabyAge", overrideAgePercent); }

    void ServerUpdateGestation() { NativeCall<void>(this, "APrimalDinoCharacter.ServerUpdateGestation"); }

    void SetAlwaysForcedAggro(bool bEnable) { NativeCall<void, bool>(this, "APrimalDinoCharacter.SetAlwaysForcedAggro", bEnable); }

    void SetAnimWeightsForAttackAtIndex(int attackIndex, TArray<float> newWeights) { NativeCall<void, int, TArray<float>>(this, "APrimalDinoCharacter.SetAnimWeightsForAttackAtIndex", attackIndex, newWeights); }

    void SetBabyAge(float TheAge) { NativeCall<void, float>(this, "APrimalDinoCharacter.SetBabyAge", TheAge); }

    void SetCarryingDino(APrimalDinoCharacter* aDino) { NativeCall<void, APrimalDinoCharacter*>(this, "APrimalDinoCharacter.SetCarryingDino", aDino); }

    void SetCharacterStatusTameable(bool bSetTameable, bool bCreateInventory, bool keepInventoryForWakingTame) { NativeCall<void, bool, bool, bool>(this, "APrimalDinoCharacter.SetCharacterStatusTameable", bSetTameable, bCreateInventory, keepInventoryForWakingTame); }

    void SetCurrentAttackIndex(char index) { NativeCall<void, char>(this, "APrimalDinoCharacter.SetCurrentAttackIndex", index); }

    void SetCurrentWeapon(AShooterWeapon* NewWeapon, AShooterWeapon* LastWeapon) { NativeCall<void, AShooterWeapon*, AShooterWeapon*>(this, "APrimalDinoCharacter.SetCurrentWeapon", NewWeapon, LastWeapon); }

    void SetDynamicMusic(USoundBase* newMusic) { NativeCall<void, USoundBase*>(this, "APrimalDinoCharacter.SetDynamicMusic", newMusic); }

    void SetFlight(bool bFly, bool bCancelForceLand) { NativeCall<void, bool, bool>(this, "APrimalDinoCharacter.SetFlight", bFly, bCancelForceLand); }

    void SetForcedAggro(ITargetableInterface* Targetable, float AggroAmount, float ForcedAggroTime) { NativeCall<void, ITargetableInterface*, float, float>(this, "APrimalDinoCharacter.SetForcedAggro", Targetable, AggroAmount, ForcedAggroTime); }

    void SetImprintPlayer(AShooterCharacter* ForChar) { NativeCall<void, AShooterCharacter*>(this, "APrimalDinoCharacter.SetImprintPlayer", ForChar); }

    void SetLastAttackTimeForAttack(int AttackIndex, long double NewTime) { NativeCall<void, int, long double>(this, "APrimalDinoCharacter.SetLastAttackTimeForAttack", AttackIndex, NewTime); }

    void SetLastMovementDesiredRotation(FRotator* InRotation) { NativeCall<void, FRotator*>(this, "APrimalDinoCharacter.SetLastMovementDesiredRotation", InRotation); }

    void SetMountCharacter(APrimalCharacter* aCharacter) { NativeCall<void, APrimalCharacter*>(this, "APrimalDinoCharacter.SetMountCharacter", aCharacter); }

    void SetMovementAccelerationVector(FVector fVector) { NativeCall<void, FVector>(this, "APrimalDinoCharacter.SetMovementAccelerationVector", fVector); }

    void SetNewStasisAutoDestroyInterval(float NewInterval) { NativeCall<void, float>(this, "APrimalDinoCharacter.SetNewStasisAutoDestroyInterval", NewInterval); }

    void SetPreventSaving(bool fPreventSaving) { NativeCall<void, bool>(this, "APrimalDinoCharacter.SetPreventSaving", fPreventSaving); }

    void SetRider(AShooterCharacter* aRider) { NativeCall<void, AShooterCharacter*>(this, "APrimalDinoCharacter.SetRider", aRider); }

    void SetRidingDinoAsPassenger(APrimalDinoCharacter* aDino, FSaddlePassengerSeatDefinition* SeatDefinition) { NativeCall<void, APrimalDinoCharacter*, FSaddlePassengerSeatDefinition*>(this, "APrimalDinoCharacter.SetRidingDinoAsPassenger", aDino, SeatDefinition); }

    void SetSleeping(bool bSleeping, bool bUseRagdollLocationOffset) { NativeCall<void, bool, bool>(this, "APrimalDinoCharacter.SetSleeping", bSleeping, bUseRagdollLocationOffset); }

    void SetStasisComponentRadius(float StasisOverrideRadius) { NativeCall<void, float>(this, "APrimalDinoCharacter.SetStasisComponentRadius", StasisOverrideRadius); }

    bool SetTurretMode_Implementation(bool enabled) { return NativeCall<bool, bool>(this, "APrimalDinoCharacter.SetTurretMode_Implementation", enabled); }

    void SetupColorization() { NativeCall<void>(this, "APrimalDinoCharacter.SetupColorization"); }

    void SetupTamed(bool bWasJustTamed) { NativeCall<void, bool>(this, "APrimalDinoCharacter.SetupTamed", bWasJustTamed); }

    bool ShouldAttackOfPlayedAnimationStopMovement() { return NativeCall<bool>(this, "APrimalDinoCharacter.ShouldAttackOfPlayedAnimationStopMovement"); }

    bool ShouldDealDamage(AActor* TestActor) { return NativeCall<bool, AActor*>(this, "APrimalDinoCharacter.ShouldDealDamage", TestActor); }

    bool ShouldDisableControllerDesiredRotation() { return NativeCall<bool>(this, "APrimalDinoCharacter.ShouldDisableControllerDesiredRotation"); }

    bool ShouldForceFlee() { return NativeCall<bool>(this, "APrimalDinoCharacter.ShouldForceFlee"); }

    bool ShouldIgnoreHitResult(UWorld* InWorld, FHitResult* TestHit, FVector* MovementDirDenormalized) { return NativeCall<bool, UWorld*, FHitResult*, FVector*>(this, "APrimalDinoCharacter.ShouldIgnoreHitResult", InWorld, TestHit, MovementDirDenormalized); }

    bool ShouldIgnoreMoveCombiningOverlap() { return NativeCall<bool>(this, "APrimalDinoCharacter.ShouldIgnoreMoveCombiningOverlap"); }

    bool ShouldReplicateRotPitch() { return NativeCall<bool>(this, "APrimalDinoCharacter.ShouldReplicateRotPitch"); }

    bool ShouldStillAllowRequestedMoveAcceleration() { return NativeCall<bool>(this, "APrimalDinoCharacter.ShouldStillAllowRequestedMoveAcceleration"); }

    bool SkipDuringPartialWorldSave() { return NativeCall<bool>(this, "APrimalDinoCharacter.SkipDuringPartialWorldSave"); }

    void SpawnDefaultController() { NativeCall<void>(this, "APrimalDinoCharacter.SpawnDefaultController"); }

    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 SpawnEgg() { NativeCall<void>(this, "APrimalDinoCharacter.SpawnEgg"); }

    void SpawnNewAIController(TSubclassOf<AController> NewAIController) { NativeCall<void, TSubclassOf<AController>>(this, "APrimalDinoCharacter.SpawnNewAIController", NewAIController); }

    bool SpecialActorWantsPerFrameTicking() { return NativeCall<bool>(this, "APrimalDinoCharacter.SpecialActorWantsPerFrameTicking"); }

    void StartCharging(bool bForce) { NativeCall<void, bool>(this, "APrimalDinoCharacter.StartCharging", bForce); }

    void StartForceSkelUpdate(float ForTime, bool bForceUpdateMesh, bool bServerOnly) { NativeCall<void, float, bool, bool>(this, "APrimalDinoCharacter.StartForceSkelUpdate", ForTime, bForceUpdateMesh, bServerOnly); }

    void StartLanding(FVector OverrideLandingLocation) { NativeCall<void, FVector>(this, "APrimalDinoCharacter.StartLanding", OverrideLandingLocation); }

    void StartRepair() { NativeCall<void>(this, "APrimalDinoCharacter.StartRepair"); }

    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); }

    void StartSurfaceCameraForPassengers(float yaw, float pitch, float roll) { NativeCall<void, float, float, float>(this, "APrimalDinoCharacter.StartSurfaceCameraForPassengers", yaw, pitch, roll); }

    void Stasis() { NativeCall<void>(this, "APrimalDinoCharacter.Stasis"); }

    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); }

    void StealDino(AShooterPlayerController* ForPC, int TargetingTeamOverride) { NativeCall<void, AShooterPlayerController*, int>(this, "APrimalDinoCharacter.StealDino", ForPC, TargetingTeamOverride); }

    void StopActiveState(bool bShouldResetAttackIndex) { NativeCall<void, bool>(this, "APrimalDinoCharacter.StopActiveState", bShouldResetAttackIndex); }

    float TakeDamage(float Damage, FDamageEvent* DamageEvent, AController* EventInstigator, AActor* DamageCauser) { return NativeCall<float, float, FDamageEvent*, AController*, AActor*>(this, "APrimalDinoCharacter.TakeDamage", Damage, DamageEvent, EventInstigator, DamageCauser); }

    void TameDino(AShooterPlayerController* ForPC, bool bIgnoreMaxTameLimit, int OverrideTamingTeamID) { NativeCall<void, AShooterPlayerController*, bool, int>(this, "APrimalDinoCharacter.TameDino", ForPC, bIgnoreMaxTameLimit, OverrideTamingTeamID); }

    void TamedDinoUnstasisConsumeFood(long double ForceTimeSinceStasis) { NativeCall<void, long double>(this, "APrimalDinoCharacter.TamedDinoUnstasisConsumeFood", ForceTimeSinceStasis); }

    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 TargetingTeamChanged() { NativeCall<void>(this, "APrimalDinoCharacter.TargetingTeamChanged"); }

    void TempDampenInputAcceleration() { NativeCall<void>(this, "APrimalDinoCharacter.TempDampenInputAcceleration"); }

    void Tick(float DeltaSeconds) { NativeCall<void, float>(this, "APrimalDinoCharacter.Tick", DeltaSeconds); }

    void TickBasedCharacters(float DeltaSeconds) { NativeCall<void, float>(this, "APrimalDinoCharacter.TickBasedCharacters", DeltaSeconds); }

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

    void UnPossessed() { NativeCall<void>(this, "APrimalDinoCharacter.UnPossessed"); }

    void UnclaimDino(bool bDestroyAI) { NativeCall<void, bool>(this, "APrimalDinoCharacter.UnclaimDino", bDestroyAI); }

    void Unstasis() { NativeCall<void>(this, "APrimalDinoCharacter.Unstasis"); }

    void UpdateAttackTargets() { NativeCall<void>(this, "APrimalDinoCharacter.UpdateAttackTargets"); }

    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); }

    void UpdateCarriedLocationAndRotation(float DeltaSeconds) { NativeCall<void, float>(this, "APrimalDinoCharacter.UpdateCarriedLocationAndRotation", DeltaSeconds); }

    void UpdateGang() { NativeCall<void>(this, "APrimalDinoCharacter.UpdateGang"); }

    void UpdateIK() { NativeCall<void>(this, "APrimalDinoCharacter.UpdateIK"); }

    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 UpdateMateBoost() { NativeCall<void>(this, "APrimalDinoCharacter.UpdateMateBoost"); }

    void UpdateMating() { NativeCall<void>(this, "APrimalDinoCharacter.UpdateMating"); }

    void UpdateStatusComponent(float DeltaSeconds) { NativeCall<void, float>(this, "APrimalDinoCharacter.UpdateStatusComponent", DeltaSeconds); }

    void UpdateTribeGroupRanks_Implementation(char NewTribeGroupPetOrderingRank, char NewTribeGroupPetRidingRank) { NativeCall<void, char, char>(this, "APrimalDinoCharacter.UpdateTribeGroupRanks_Implementation", NewTribeGroupPetOrderingRank, NewTribeGroupPetRidingRank); }

    void UpdateWakingTame(float DeltaTime) { NativeCall<void, float>(this, "APrimalDinoCharacter.UpdateWakingTame", DeltaTime); }

    bool UseLowQualityAnimationTick() { return NativeCall<bool>(this, "APrimalDinoCharacter.UseLowQualityAnimationTick"); }

    bool UseLowQualityBehaviorTreeTick() { return NativeCall<bool>(this, "APrimalDinoCharacter.UseLowQualityBehaviorTreeTick"); }

    bool UseLowQualityMovementTick() { return NativeCall<bool>(this, "APrimalDinoCharacter.UseLowQualityMovementTick"); }

    bool FlyingUseHighQualityCollision() { return NativeCall<bool>(this, "APrimalDinoCharacter.FlyingUseHighQualityCollision"); }

    bool WalkingAllowCheckFall(FVector* DeltaWalk) { return NativeCall<bool, FVector*>(this, "APrimalDinoCharacter.WalkingAllowCheckFall", DeltaWalk); }

    bool WalkingAllowCheckFloor(FVector* DeltaWalk) { return NativeCall<bool, FVector*>(this, "APrimalDinoCharacter.WalkingAllowCheckFloor", DeltaWalk); }

    bool WantsPerFrameSkeletalAnimationTicking() { return NativeCall<bool>(this, "APrimalDinoCharacter.WantsPerFrameSkeletalAnimationTicking"); }

    int WasAllowedToTickThisFrame() { return NativeCall<int>(this, "APrimalDinoCharacter.WasAllowedToTickThisFrame"); }

    void WasPushed(ACharacter* ByOtherCharacter) { NativeCall<void, ACharacter*>(this, "APrimalDinoCharacter.WasPushed", ByOtherCharacter); }

    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"); }

    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 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 BPCanTargetCorpse() { return NativeCall<bool>(this, "APrimalDinoCharacter.BPCanTargetCorpse"); }

    FVector* BPChargingModifyInputAcceleration(FVector* result, FVector inputAcceleration) { return NativeCall<FVector*, FVector*, FVector>(this, "APrimalDinoCharacter.BPChargingModifyInputAcceleration", result, inputAcceleration); }

    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 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"); }

    FName* BPGetDragSocketDinoName(FName* result, APrimalDinoCharacter* aGrabbedDino) { return NativeCall<FName*, FName*, APrimalDinoCharacter*>(this, "APrimalDinoCharacter.BPGetDragSocketDinoName", result, aGrabbedDino); }

    FVector* BPGetHealthBarColor(FVector* result) { return NativeCall<FVector*, FVector*>(this, "APrimalDinoCharacter.BPGetHealthBarColor", result); }

    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); }

    void BPKilledSomethingEvent(APrimalCharacter* killedTarget) { NativeCall<void, APrimalCharacter*>(this, "APrimalDinoCharacter.BPKilledSomethingEvent", killedTarget); }

    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 BPOnClearMountedDino() { NativeCall<void>(this, "APrimalDinoCharacter.BPOnClearMountedDino"); }

    void BPOnEndCharging() { NativeCall<void>(this, "APrimalDinoCharacter.BPOnEndCharging"); }

    void BPOnRepIsCharging() { NativeCall<void>(this, "APrimalDinoCharacter.BPOnRepIsCharging"); }

    void BPOnSaddleStructuresUpdated(APrimalStructure* SaddleStructure, bool bWasRemoved) { NativeCall<void, APrimalStructure*, bool>(this, "APrimalDinoCharacter.BPOnSaddleStructuresUpdated", SaddleStructure, bWasRemoved); }

    void BPOnSetFlight(bool bFly) { NativeCall<void, bool>(this, "APrimalDinoCharacter.BPOnSetFlight", bFly); }

    void BPOnSetMountedDino() { NativeCall<void>(this, "APrimalDinoCharacter.BPOnSetMountedDino"); }

    void BPOnStartCharging() { NativeCall<void>(this, "APrimalDinoCharacter.BPOnStartCharging"); }

    bool BPOnStartJump() { return NativeCall<bool>(this, "APrimalDinoCharacter.BPOnStartJump"); }

    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, AActor* DestActor) { NativeCall<void, FVector*, AActor*>(this, "APrimalDinoCharacter.BPOrderedMoveToLoc", DestLoc, DestActor); }

    bool BPOverrideMoveToOrder(FVector MoveToLocation, AShooterCharacter* OrderingPlayer, AActor* TargetActor) { return NativeCall<bool, FVector, AShooterCharacter*, AActor*>(this, "APrimalDinoCharacter.BPOverrideMoveToOrder", MoveToLocation, OrderingPlayer, TargetActor); }

    void BPPreOnSaddleStructuresAdded(APrimalStructure* SaddleStructure) { NativeCall<void, APrimalStructure*>(this, "APrimalDinoCharacter.BPPreOnSaddleStructuresAdded", SaddleStructure); }

    bool BPPreventAIAttackSelection() { return NativeCall<bool>(this, "APrimalDinoCharacter.BPPreventAIAttackSelection"); }

    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"); }

    void BPTamedConsumeFoodItem(UPrimalItem* foodItem) { NativeCall<void, UPrimalItem*>(this, "APrimalDinoCharacter.BPTamedConsumeFoodItem", foodItem); }

    void BPUnsetupDinoTameable() { NativeCall<void>(this, "APrimalDinoCharacter.BPUnsetupDinoTameable"); }

    void BPUntamedConsumeFoodItem(UPrimalItem* foodItem) { NativeCall<void, UPrimalItem*>(this, "APrimalDinoCharacter.BPUntamedConsumeFoodItem", foodItem); }

    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); }

    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_OnStartLandingNotify() { NativeCall<void>(this, "APrimalDinoCharacter.BP_OnStartLandingNotify"); }

    void BP_OnTargetedByTamedOrder(APrimalCharacter* OrderingCharacter, APrimalDinoCharacter* AttackingDino, bool bForced) { NativeCall<void, APrimalCharacter*, APrimalDinoCharacter*, bool>(this, "APrimalDinoCharacter.BP_OnTargetedByTamedOrder", OrderingCharacter, AttackingDino, bForced); }

    FVector* BP_OverrideClosestShipEdgeTeleportLocation(FVector* result, FVector CurrentShipEdgeLocation, APrimalRaft* ForShip) { return NativeCall<FVector*, FVector*, FVector, APrimalRaft*>(this, "APrimalDinoCharacter.BP_OverrideClosestShipEdgeTeleportLocation", result, CurrentShipEdgeLocation, ForShip); }

    bool BP_PreventCarrying() { return NativeCall<bool>(this, "APrimalDinoCharacter.BP_PreventCarrying"); }

    void BSetupDinoTameable() { NativeCall<void>(this, "APrimalDinoCharacter.BSetupDinoTameable"); }

    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"); }

    void CheckStructurePlacementOnMe(int* AllowReturnValue, APrimalStructure* PlacingStructure, AShooterPlayerController* PC, FVector* AtLocation, FRotator* AtRotation, FPlacementData* PlacementData) { NativeCall<void, int*, APrimalStructure*, AShooterPlayerController*, FVector*, FRotator*, FPlacementData*>(this, "APrimalDinoCharacter.CheckStructurePlacementOnMe", AllowReturnValue, PlacingStructure, PC, AtLocation, AtRotation, PlacementData); }

    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 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); }

    USoundBase* GetDinoTameSound() { return NativeCall<USoundBase*>(this, "APrimalDinoCharacter.GetDinoTameSound"); }

    static UClass* GetPrivateStaticClass(const wchar_t* Package) { return NativeCall<UClass*, const wchar_t*>(nullptr, "APrimalDinoCharacter.GetPrivateStaticClass", Package); }

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

    void HandleMountedDinoAction(AShooterPlayerController* PC) { NativeCall<void, AShooterPlayerController*>(this, "APrimalDinoCharacter.HandleMountedDinoAction", PC); }

    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 OnNPCStartedAttack(int AttackIndex, int AnimationIndex, bool bIsAltAnim, AActor* MyTarget) { NativeCall<void, int, int, bool, AActor*>(this, "APrimalDinoCharacter.OnNPCStartedAttack", AttackIndex, AnimationIndex, bIsAltAnim, MyTarget); }

    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() { NativeCall<void>(this, "APrimalDinoCharacter.RidingTick"); }

    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); }

    static void StaticRegisterNativesAPrimalDinoCharacter() { NativeCall<void>(nullptr, "APrimalDinoCharacter.StaticRegisterNativesAPrimalDinoCharacter"); }

    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); }

};


struct AShooterWeapon : AActor

{

    float& EquipTimeField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.EquipTime"); }

    long double& LastTimeInReloadingField() { return *GetNativePointerField<long double*>(this, "AShooterWeapon.LastTimeInReloading"); }

    TEnumAsByte<enum EWeaponType::Type>& MyWeaponTypeField() { return *GetNativePointerField<TEnumAsByte<enum EWeaponType::Type>*>(this, "AShooterWeapon.MyWeaponType"); }

    UAnimMontage* OverrideProneInAnimField() { return *GetNativePointerField<UAnimMontage * *>(this, "AShooterWeapon.OverrideProneInAnim"); }

    UAnimMontage* NewOverrideProneOutAnimField() { return *GetNativePointerField<UAnimMontage * *>(this, "AShooterWeapon.NewOverrideProneOutAnim"); }

    UAnimMontage* OverrideJumpAnimField() { return *GetNativePointerField<UAnimMontage * *>(this, "AShooterWeapon.OverrideJumpAnim"); }

    UAnimMontage* OverrideJumpAnimDualWieldingField() { return *GetNativePointerField<UAnimMontage * *>(this, "AShooterWeapon.OverrideJumpAnimDualWielding"); }

    UAnimMontage* NewOverrideLandedAnimField() { return *GetNativePointerField<UAnimMontage * *>(this, "AShooterWeapon.NewOverrideLandedAnim"); }

    UAnimMontage* NewOverrideLandedAnimDualWieldingField() { return *GetNativePointerField<UAnimMontage * *>(this, "AShooterWeapon.NewOverrideLandedAnimDualWielding"); }

    UAnimMontage* OverrideJumpAnim_RunningModeField() { return *GetNativePointerField<UAnimMontage * *>(this, "AShooterWeapon.OverrideJumpAnim_RunningMode"); }

    UAnimMontage* NewOverrideLandedAnim_RunningModeField() { return *GetNativePointerField<UAnimMontage * *>(this, "AShooterWeapon.NewOverrideLandedAnim_RunningMode"); }

    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"); }

    float& TargetingForceTraceFloatingHUDRangeField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.TargetingForceTraceFloatingHUDRange"); }

    long double& LastTimePlayedSwitchAnimField() { return *GetNativePointerField<long double*>(this, "AShooterWeapon.LastTimePlayedSwitchAnim"); }

    float& GlobalAttackAutoAimMultiplierField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.GlobalAttackAutoAimMultiplier"); }

    float& AttackAutoAimSliderField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.AttackAutoAimSlider"); }

    float& AttackAutoAimSliderMaxMultiplierField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.AttackAutoAimSliderMaxMultiplier"); }

    float& AttackAutoAimSliderMinMultiplierField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.AttackAutoAimSliderMinMultiplier"); }

    long double& TimeStartedAutoAimField() { return *GetNativePointerField<long double*>(this, "AShooterWeapon.TimeStartedAutoAim"); }

    FVector& AutoAimViewOffsetField() { return *GetNativePointerField<FVector*>(this, "AShooterWeapon.AutoAimViewOffset"); }

    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"); }

    FTransform& LastDiscreteMeleeSwingTransformField() { return *GetNativePointerField<FTransform*>(this, "AShooterWeapon.LastDiscreteMeleeSwingTransform"); }

    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"); }

    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"); }

    APrimalCharacter* MyPawnField() { return *GetNativePointerField<APrimalCharacter * *>(this, "AShooterWeapon.MyPawn"); }

    UAudioComponent* FireACField() { return *GetNativePointerField<UAudioComponent * *>(this, "AShooterWeapon.FireAC"); }

    FName& MuzzleAttachPointField() { return *GetNativePointerField<FName*>(this, "AShooterWeapon.MuzzleAttachPoint"); }

    FName& MuzzleAttachPointSecondaryField() { return *GetNativePointerField<FName*>(this, "AShooterWeapon.MuzzleAttachPointSecondary"); }

    FName& FastAttackFXSocketField() { return *GetNativePointerField<FName*>(this, "AShooterWeapon.FastAttackFXSocket"); }

    FName& FastAttackLeftFXSocketField() { return *GetNativePointerField<FName*>(this, "AShooterWeapon.FastAttackLeftFXSocket"); }

    FName& MeleeStunFXSocketField() { return *GetNativePointerField<FName*>(this, "AShooterWeapon.MeleeStunFXSocket"); }

    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"); }

    USoundCue* UnequipSoundField() { return *GetNativePointerField<USoundCue * *>(this, "AShooterWeapon.UnequipSound"); }

    UAnimMontage* WeaponMesh3PFireAnimField() { return *GetNativePointerField<UAnimMontage * *>(this, "AShooterWeapon.WeaponMesh3PFireAnim"); }

    TSubclassOf<UWeaponAttackData>& WeaponAttackDataClassField() { return *GetNativePointerField<TSubclassOf<UWeaponAttackData>*>(this, "AShooterWeapon.WeaponAttackDataClass"); }

    TSubclassOf<UWeaponAttackData>& AIWeaponAttackDataClassField() { return *GetNativePointerField<TSubclassOf<UWeaponAttackData>*>(this, "AShooterWeapon.AIWeaponAttackDataClass"); }

    UWeaponAttackData* CurrentWeaponAttackDataField() { return *GetNativePointerField<UWeaponAttackData * *>(this, "AShooterWeapon.CurrentWeaponAttackData"); }

    UWeaponAttackData* CurrentShieldAttackDataField() { return *GetNativePointerField<UWeaponAttackData * *>(this, "AShooterWeapon.CurrentShieldAttackData"); }

    TArray<TEnumAsByte<enum EWeaponAttackType::Type>>& WeaponAttackTypeOverrideField() { return *GetNativePointerField<TArray<TEnumAsByte<enum EWeaponAttackType::Type>>*>(this, "AShooterWeapon.WeaponAttackTypeOverride"); }

    TArray<int>& WeaponAttackIndexOverrideField() { return *GetNativePointerField<TArray<int>*>(this, "AShooterWeapon.WeaponAttackIndexOverride"); }

    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& FPVMoveOffscreenIdleInCombatRestoreIntervalField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.FPVMoveOffscreenIdleInCombatRestoreInterval"); }

    float& FPVMoveOffscreenIdleRestoreSpeedField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.FPVMoveOffscreenIdleRestoreSpeed"); }

    float& FPVMoveOffscreenWhenTurningMaxOffsetField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.FPVMoveOffscreenWhenTurningMaxOffset"); }

    float& FPVMoveOffscreenWhenTurningInCombatMaxOffsetField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.FPVMoveOffscreenWhenTurningInCombatMaxOffset"); }

    long double& FPVStoppedTurningTimeField() { return *GetNativePointerField<long double*>(this, "AShooterWeapon.FPVStoppedTurningTime"); }

    float& ItemDestructionUnequipWeaponDelayField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.ItemDestructionUnequipWeaponDelay"); }

    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"); }

    float& AutoAimRangeField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.AutoAimRange"); }

    float& MaxAngleToActivateAutoAimField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.MaxAngleToActivateAutoAim"); }

    float& LookForAutoAimTargetDurationField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.LookForAutoAimTargetDuration"); }

    float& DodgeAutoAimMinSpeedField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.DodgeAutoAimMinSpeed"); }

    float& DodgeAutoAimMaxSpeedField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.DodgeAutoAimMaxSpeed"); }

    float& DodgeAutoAimDurationField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.DodgeAutoAimDuration"); }

    float& DodgeAutoAimMaxDistanceForSpeedAdjustementField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.DodgeAutoAimMaxDistanceForSpeedAdjustement"); }

    float& DodgeAutoAimMinDistanceForSpeedAdjustementField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.DodgeAutoAimMinDistanceForSpeedAdjustement"); }

    float& DodgeAutoAimRangeField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.DodgeAutoAimRange"); }

    float& TimeBeforeDodgingEndsToStartNextAttackField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.TimeBeforeDodgingEndsToStartNextAttack"); }

    float& TimeBeforeDodgingEndsToStoreNextAttackField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.TimeBeforeDodgingEndsToStoreNextAttack"); }

    float& TimeBeforeAttackEndsToStoreDodgingField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.TimeBeforeAttackEndsToStoreDodging"); }

    AActor* AutoAimTargetField() { return *GetNativePointerField<AActor * *>(this, "AShooterWeapon.AutoAimTarget"); }

    float& LockOnAimMinSpeedField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.LockOnAimMinSpeed"); }

    float& LockOnAimMaxSpeedField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.LockOnAimMaxSpeed"); }

    float& LockOnAimMaxDistanceForSpeedAdjustementField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.LockOnAimMaxDistanceForSpeedAdjustement"); }

    float& LockOnAimMinDistanceForSpeedAdjustementField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.LockOnAimMinDistanceForSpeedAdjustement"); }

    long double& LastTimeStartedLookingForAimTargetField() { return *GetNativePointerField<long double*>(this, "AShooterWeapon.LastTimeStartedLookingForAimTarget"); }

    float& DodgeMeleeDamageMultiplierField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.DodgeMeleeDamageMultiplier"); }

    float& DodgeMeleeImpulseMultiplierField() { return *GetNativePointerField<float*>(this, "AShooterWeapon.DodgeMeleeImpulseMultiplier"); }

    long double& LastAttackTimeField() { return *GetNativePointerField<long double*>(this, "AShooterWeapon.LastAttackTime"); }

    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"); }

    int& CurrentWeaponAttackIndexField() { return *GetNativePointerField<int*>(this, "AShooterWeapon.CurrentWeaponAttackIndex"); }

    int&