ase/_a_r_k_2_actor_8h_source.html

#pragma once


#include "../Base.h"


struct FChatMessage

{

    FString SenderName;

    FString SenderSteamName;

    FString SenderTribeName;

    unsigned int SenderId;

    FString Message;

    FString Receiver;

    int SenderTeamIndex;

    long double ReceivedTime;

    TEnumAsByte<EChatSendMode::Type> SendMode;

    unsigned int RadioFrequency;

    TEnumAsByte<enum EChatType::Type> ChatType;

    UTexture2D* SenderIcon;

    FString UserId;


    FChatMessage()

        : SenderName(""),

        SenderSteamName(""),

        SenderTribeName(""),

        SenderId(0),

        Message(""),

        Receiver(""),

        SenderTeamIndex(0),

        ReceivedTime(-1),

        SendMode(EChatSendMode::GlobalChat),

        RadioFrequency(0),

        ChatType(EChatType::GlobalChat),

        SenderIcon(nullptr),

        UserId("")

    {

    }


    FChatMessage(FChatMessage* __that) { NativeCall<void, FChatMessage *>(this, "FChatMessage.FChatMessage", __that); }

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

};


struct FUniqueNetIdRepl

{

    TSharedPtr<FUniqueNetId> UniqueNetId;

};


struct FWeightedObjectList

{

    TArray<float> Weights;

    TArray<UObject*> AssociatedObjects;

};


struct FActorSpawnParameters

{

    FActorSpawnParameters()

        : Name()

        , Template(NULL)

        , Owner(NULL)

        , Instigator(NULL)

        , OverrideLevel(NULL)

        , bNoCollisionFail(0)

        , bRemoteOwned(false)

        , bNoFail(false)

        , bDeferruction(false)

        , bAllowDuringructionScript(false)

        , bDeferBeginPlay(0)

        , ExtraSpawnData(0)

        , ObjectFlags(EObjectFlags::RF_Transactional)

        , AttachToComponent(nullptr)

    {

    }


    FName Name;

    AActor *Template;

    AActor *Owner;

    APawn *Instigator;

    ULevel *OverrideLevel;

    unsigned __int32 bNoCollisionFail : 1;

    unsigned __int32 bRemoteOwned : 1;

    unsigned __int32 bNoFail : 1;

    unsigned __int32 bDeferruction : 1;

    unsigned __int32 bAllowDuringructionScript : 1;

    unsigned __int32 bDeferBeginPlay : 1;

    int ExtraSpawnData;

    EObjectFlags ObjectFlags;

    USceneComponent *AttachToComponent;

    FName AttachToBoneName;

};


struct FItemSetup

{

    TSubclassOf<UPrimalItem> ItemType;

    FString ItemBlueprintPath;

    float MinQuality;

    float MaxQuality;

    int Quantity;

    __int8 bAutoEquip : 1;

    __int8 bDontStack : 1;

    __int8 bForceBlueprint : 1;

};


struct __declspec(align(8)) FDinoSetup

{

    TSubclassOf<APrimalDinoCharacter> DinoType;

    FString DinoBlueprintPath;

    FString DinoName;

    int DinoLevel;

    char BasePointsPerStat[12];

    char PlayerAddedPointsPerStat[12];

    FVector SpawnOffset;

    TEnumAsByte<enum EDinoTamedOrder::Type> DinoState;

    TArray<TEnumAsByte<enum EPrimalCharacterStatusValue::Type>> PrioritizeStats;

    TArray<FItemSetup> TamedDinoInventory;

    TSubclassOf<UPrimalItem> SaddleType;

    FString SaddleBlueprintPath;

    float SaddleQuality;

    float SaddleMinRandomQuality;

    unsigned __int32 bIsTamed : 1;

    unsigned __int32 bIgnoreMaxTameLimit : 1;

    unsigned __int32 bBlockTamedDialog : 1;

    unsigned __int32 bAutoEquipSaddle : 1;

    unsigned __int32 bUseFixedSpawnLevel : 1;

};


struct FPlayerDeathReason

{

    int PlayerID;

    FString DeathReason;

    long double DiedAtTime;

};


struct __declspec(align(8)) FPrimalPlayerCharacterConfigStruct

{

    __int8 bIsFemale : 1;

    FLinearColor BodyColors[4];

    FLinearColor OverrideHeadHairColor;

    FLinearColor OverrideFacialHairColor;

    char FacialHairIndex;

    char HeadHairIndex;

    FString PlayerCharacterName;

    float RawBoneModifiers[22];

    int PlayerSpawnRegionIndex;


    FPrimalPlayerCharacterConfigStruct()

    {

        FLinearColor black = FLinearColor(0, 0, 0);

        bIsFemale = false;

        for (int i = 0; i < 4; ++i)

            BodyColors[i] = black;

        OverrideHeadHairColor = black;

        OverrideFacialHairColor = black;

        PlayerSpawnRegionIndex = 0;

        PlayerCharacterName = L"Survivor";

        FMemory::Memzero(&RawBoneModifiers, sizeof(RawBoneModifiers));

    }

};


struct FPrimalPlayerCharacterConfigStructReplicated

{

    uint8 bIsFemale : 1;

    FLinearColor BodyColors[4];

    FString PlayerCharacterName;

    float RawBoneModifiers[22];

    int32 PlayerSpawnRegionIndex;


    FPrimalPlayerCharacterConfigStructReplicated()

    {

        FLinearColor black = FLinearColor(0, 0, 0);

        bIsFemale = false;

        for (int i = 0; i < 4; ++i)

            BodyColors[i] = black;

        PlayerSpawnRegionIndex = 0;

        PlayerCharacterName = L"Survivor";

        FMemory::Memzero(&RawBoneModifiers, sizeof(RawBoneModifiers));

    }


    FPrimalPlayerCharacterConfigStructReplicated(const FPrimalPlayerCharacterConfigStruct& original)

    {

        bIsFemale = original.bIsFemale;

        PlayerCharacterName = original.PlayerCharacterName;

        PlayerSpawnRegionIndex = original.PlayerSpawnRegionIndex;

        FMemory::Memcpy(&BodyColors, &original.BodyColors, sizeof(BodyColors));

        FMemory::Memcpy(&RawBoneModifiers, &original.RawBoneModifiers, sizeof(RawBoneModifiers));

    }


    FPrimalPlayerCharacterConfigStruct GetPlayerCharacterConfig()

    {

        FPrimalPlayerCharacterConfigStruct toReturn;

        toReturn.bIsFemale = bIsFemale;

        toReturn.PlayerCharacterName = PlayerCharacterName;

        toReturn.PlayerSpawnRegionIndex = PlayerSpawnRegionIndex;

        FMemory::Memcpy(&toReturn.BodyColors, &BodyColors, sizeof(BodyColors));

        FMemory::Memcpy(&toReturn.RawBoneModifiers, &RawBoneModifiers, sizeof(RawBoneModifiers));

        return toReturn;

    }

};


struct FPrimalCharacterStatusValueModifier

{

    EPrimalCharacterStatusValue::Type ValueType;

    EPrimalCharacterStatusValue::Type StopOnValueNearMax;

    float AmountToAdd;

    float BaseAmountToAdd;

    float SpeedToAdd;

    bool bContinueOnUnchangedValue;

    bool bSetValue;

    bool bSetAdditionalValue;

    bool bMakeUntameable;

    int StatusValueModifierDescriptionIndex;

};


struct FArkTributeEntity

{

    int UploadTime;

};


struct FARKTributeDino : FArkTributeEntity

{

    FString DinoClassName;

    UClass* DinoClass;

    TArray<unsigned char> DinoData;

    FString DinoName;

    FString DinoNameInMap;

    FString DinoStats[12];

    float DinoExperiencePoints;

    float Version;

    unsigned int DinoID1;

    unsigned int DinoID2;

};


struct FARKDinoData

{

    UClass* DinoClass;

    TArray<unsigned char> DinoData;

    FString DinoNameInMap;

    FString DinoName;

};


struct FDinoBaseLevelWeightEntry

{

    float EntryWeight;

    float BaseLevelMinRange;

    float BaseLevelMaxRange;

};


struct __declspec(align(8)) FClassRemappingWeight

{

    TSubclassOf<UObject> FromClass;

    TArray<TSubclassOf<UObject>> ToClasses;

    TArray<float> Weights;

    FName ActiveEvent;

    unsigned __int32 bExactMatch : 1;

};


struct FClassNameReplacement

{

    FString FromClassName;

    FString ToClassName;

};


struct FNPCDifficultyLevelRange

{

    TArray<float> EnemyLevelsMin;

    TArray<float> EnemyLevelsMax;

    TArray<float> GameDifficulties;

};


struct FAlivePlayerDataInfo

{

    FString PlayerName;

    FString PlayerSteamName;

    unsigned __int64 PlayerID;

    FString TribeName;

    unsigned __int64 TargetingTeamID;

};


struct FAdminPlayerDataInfo

{

    FString PlayerName;

    FString PlayerSteamName;

    FString SteamID;

    __int64 LinkedPlayerID;

    bool IsHost;

};


struct FNPCSpawnEntry

{

    FString AnEntryName;

    TArray<TSubclassOf<APrimalDinoCharacter>> NPCsToSpawn;

    TArray<FString> NPCsToSpawnStrings;

    TArray<FClassRemappingWeight> NPCRandomSpawnClassWeights;

    TArray<FVector> NPCsSpawnOffsets;

    TArray<float> NPCsToSpawnPercentageChance;

    TArray<float> NPCMinLevelOffset;

    TArray<float> NPCMaxLevelOffset;

    TArray<float> NPCMinLevelMultiplier;

    TArray<float> NPCMaxLevelMultiplier;

    unsigned __int32 bAddLevelOffsetBeforeMultiplier : 1;

    TArray<unsigned char> NPCOverrideLevel;

    FVector ExtentCheck;

    FVector GroupSpawnOffset;

    float EntryWeight;

    float ManualSpawnPointSpreadRadius;

    float WaterOnlySpawnMinimumWaterHeight;

    float MaximumWaterHeight;

    TArray<FNPCDifficultyLevelRange> NPCDifficultyLevelRanges;

    float LevelDifficultyTestOverride;

    float SpawnMinDistanceFromStructuresMultiplier;

    float SpawnMinDistanceFromPlayersMultiplier;

    float SpawnMinDistanceFromTamedDinosMultiplier;

    float RandGroupSpawnOffsetZMin;

    float RandGroupSpawnOffsetZMax;

};


struct FNPCSpawnLimit

{

    TSubclassOf<APrimalDinoCharacter> NPCClass;

    FString NPCClassString;

    float MaxPercentageOfDesiredNumToAllow;

    int CurrentNumberOfNPCTouching;

};


struct __declspec(align(8)) UNPCSpawnEntriesContainer : UObject

{

    TArray<FNPCSpawnEntry> NPCSpawnEntries;

    TArray<FNPCSpawnLimit> NPCSpawnLimits;

    float MaxDesiredNumEnemiesMultiplier;

};


struct FConfigCacheIni

{

};


struct FARKTributeDinoListing

{

    FString DinoName;

    FString DinoStats[12];

    float DinoExperiencePoints;

    UClass* DinoClass;

    unsigned int DinoID1;

    unsigned int DinoID2;

    unsigned int ExpirationTimeUTC;

};


struct FPrimalCharacterStatusStateDefinition

{

    TEnumAsByte<enum EPrimalCharacterStatusValue::Type> StatusValueType;

    int StatusValueThresholdIndex;

    UTexture2D* StatusStateIcon;

    FString StatusStateName;

    FString StatusStateDescription;

    FColor StatusStateNameColor;

    bool bUsed;

    bool bDisplayHUDMessage;

    FString HUDMessage;

    FColor HUDMessageColor;

    int BuffType;

};


struct __declspec(align(8)) FPrimalCharacterStatusValueDefinition

{

    UTexture2D* StatusValueIcon;

    FString StatusValueName;

    bool bLevelUpSetToMaxValue;

    bool bDisplayHideCurrentValue;

    bool bDisplayAsPercent;

};


struct FARKTributeData

{

    FGuid ID;

    TEnumAsByte<enum EPrimalARKTributeDataType::Type> DataType;

    TArray<unsigned char> DataBytes;

    FString DataClassName;

    FString DataTagName;

    FString Name;

    TArray<FString> DataStats;

    long double LastReceiveDataTime;

    unsigned int DataID1;

    unsigned int DataID2;

};


struct FArkTributePlayerDataListing

{

    unsigned __int64 PlayerDataID;

    FString PlayerName;

    FString PlayerStats[12];

    bool bWasAllowDPCUpload;

    FString UploadingServerMapName;

    bool bWithItems;

    unsigned int ItemCount;

    float Version;

    unsigned int ExpirationTimeUTC;

};


struct FArkTributePlayerData : FArkTributeEntity

{

    unsigned __int64 PlayerDataID;

    TArray<unsigned char> PlayerDataBytes;

    FString PlayerName;

    FString PlayerStats[12];

    FString UploadingServerMapName;

    bool bWasAllowDPCUpload;

    bool bWithItems;

    unsigned int ItemCount;

    bool bForServerTransfer;

    float Version;

};


struct USceneComponent : UActorComponent

{

    FTransform& ComponentToWorldField() { return *GetNativePointerField<FTransform*>(this, "USceneComponent.ComponentToWorld"); }

    TEnumAsByte<enum EComponentMobility::Type>& MobilityField() { return *GetNativePointerField<TEnumAsByte<enum EComponentMobility::Type>*>(this, "USceneComponent.Mobility"); }

    FBoxSphereBounds& BoundsField() { return *GetNativePointerField<FBoxSphereBounds*>(this, "USceneComponent.Bounds"); }

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

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

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

    FVector& RelativeLocationField() { return *GetNativePointerField<FVector*>(this, "USceneComponent.RelativeLocation"); }

    FRotator& RelativeRotationField() { return *GetNativePointerField<FRotator*>(this, "USceneComponent.RelativeRotation"); }

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

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

    bool& NetUpdateTransformField() { return *GetNativePointerField<bool*>(this, "USceneComponent.NetUpdateTransform"); }

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

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

    FVector& RelativeScale3DField() { return *GetNativePointerField<FVector*>(this, "USceneComponent.RelativeScale3D"); }

    FVector& ComponentVelocityField() { return *GetNativePointerField<FVector*>(this, "USceneComponent.ComponentVelocity"); }


    // Bit fields


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


    // Functions


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

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

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


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

    TArray<FName>* GetAllSocketNames(TArray<FName>* result) { return NativeCall<TArray<FName>*, TArray<FName>*>(this, "USceneComponent.GetAllSocketNames", result); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    void SetWorldScale3D(FVector NewScale) { NativeCall<void, FVector>(this, "USceneComponent.SetWorldScale3D", NewScale); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    bool MoveComponentImpl(FVector* Delta, FQuat* NewRotation, bool bSweep, FHitResult* OutHit, EMoveComponentFlags MoveFlags, bool bUpdateOverlaps) { return NativeCall<bool, FVector*, FQuat*, bool, FHitResult*, EMoveComponentFlags, bool>(this, "USceneComponent.MoveComponentImpl", Delta, NewRotation, bSweep, OutHit, MoveFlags, bUpdateOverlaps); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

};


struct UPrimitiveComponent : USceneComponent

{

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

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

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

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

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

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

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

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

    TEnumAsByte<enum EIndirectLightingCacheQuality>& IndirectLightingCacheQualityField() { return *GetNativePointerField<TEnumAsByte<enum EIndirectLightingCacheQuality>*>(this, "UPrimitiveComponent.IndirectLightingCacheQuality"); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    TEnumAsByte<enum ECanBeCharacterBase>& CanCharacterStepUpOnField() { return *GetNativePointerField<TEnumAsByte<enum ECanBeCharacterBase>*>(this, "UPrimitiveComponent.CanCharacterStepUpOn"); }

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

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

    FComponentEndOverlapSignature& OnComponentEndOverlapField() { return *GetNativePointerField<FComponentEndOverlapSignature*>(this, "UPrimitiveComponent.OnComponentEndOverlap"); }

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

    FComponentEndCursorOverSignature& OnEndCursorOverField() { return *GetNativePointerField<FComponentEndCursorOverSignature*>(this, "UPrimitiveComponent.OnEndCursorOver"); }

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

    FComponentOnReleasedSignature& OnReleasedField() { return *GetNativePointerField<FComponentOnReleasedSignature*>(this, "UPrimitiveComponent.OnReleased"); }

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

    FComponentOnInputTouchEndSignature& OnInputTouchEndField() { return *GetNativePointerField<FComponentOnInputTouchEndSignature*>(this, "UPrimitiveComponent.OnInputTouchEnd"); }

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

    FComponentEndTouchOverSignature& OnInputTouchLeaveField() { return *GetNativePointerField<FComponentEndTouchOverSignature*>(this, "UPrimitiveComponent.OnInputTouchLeave"); }

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

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

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


    // Bit fields


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


    // Functions


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    bool MoveComponentImpl(FVector* Delta, FQuat* NewRotationQuat, bool bSweep, FHitResult* OutHit, EMoveComponentFlags MoveFlags, bool bUpdateOverlaps) { return NativeCall<bool, FVector*, FQuat*, bool, FHitResult*, EMoveComponentFlags, bool>(this, "UPrimitiveComponent.MoveComponentImpl", Delta, NewRotationQuat, bSweep, OutHit, MoveFlags, bUpdateOverlaps); }

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

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

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

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

    bool LineTraceComponent(FHitResult* OutHit, FVector Start, FVector End, FCollisionQueryParams* Params) { return NativeCall<bool, FHitResult*, FVector, FVector, FCollisionQueryParams*>(this, "UPrimitiveComponent.LineTraceComponent", OutHit, Start, End, Params); }

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

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

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

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

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

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

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

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

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

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

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

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

    void DispatchOnInputTouchBegin(ETouchIndex::Type FingerIndex) { NativeCall<void, ETouchIndex::Type>(this, "UPrimitiveComponent.DispatchOnInputTouchBegin", FingerIndex); }

    void DispatchOnInputTouchEnd(ETouchIndex::Type FingerIndex) { NativeCall<void, ETouchIndex::Type>(this, "UPrimitiveComponent.DispatchOnInputTouchEnd", FingerIndex); }

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

    void SetCollisionResponseSet(FCollisionResponseSet* Col) { NativeCall<void, FCollisionResponseSet*>(this, "UPrimitiveComponent.SetCollisionResponseSet", Col); }

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

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

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

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

    void AddImpulse(FVector Impulse, FName BoneName, bool bVelChange) { NativeCall<void, FVector, FName, bool>(this, "UPrimitiveComponent.AddImpulse", Impulse, BoneName, bVelChange); }

    void AddImpulseAtLocation(FVector Impulse, FVector Location, FName BoneName) { NativeCall<void, FVector, FVector, FName>(this, "UPrimitiveComponent.AddImpulseAtLocation", Impulse, Location, BoneName); }

    void AddRadialImpulse(FVector Origin, float Radius, float Strength, ERadialImpulseFalloff Falloff, bool bVelChange) { NativeCall<void, FVector, float, float, ERadialImpulseFalloff, bool>(this, "UPrimitiveComponent.AddRadialImpulse", Origin, Radius, Strength, Falloff, bVelChange); }

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

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

    void AddRadialForce(FVector Origin, float Radius, float Strength, ERadialImpulseFalloff Falloff) { NativeCall<void, FVector, float, float, ERadialImpulseFalloff>(this, "UPrimitiveComponent.AddRadialForce", Origin, Radius, Strength, Falloff); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    bool K2_LineTraceComponent(FVector TraceStart, FVector TraceEnd, bool bTraceComplex, bool bShowTrace, FVector* HitLocation, FVector* HitNormal, FName* BoneName) { return NativeCall<bool, FVector, FVector, bool, bool, FVector*, FVector*, FName*>(this, "UPrimitiveComponent.K2_LineTraceComponent", TraceStart, TraceEnd, bTraceComplex, bShowTrace, HitLocation, HitNormal, BoneName); }

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

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

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

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

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

};


struct UShapeComponent : UPrimitiveComponent

{

    UMaterialInterface* ShapeMaterialField() { return *GetNativePointerField<UMaterialInterface**>(this, "UShapeComponent.ShapeMaterial"); }


    // Bit fields


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

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


    // Functions


    bool ShouldCollideWhenPlacing() { return NativeCall<bool>(this, "UShapeComponent.ShouldCollideWhenPlacing"); }

};


struct USphereComponent : UShapeComponent

{


    // Functions


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

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

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

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

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

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

    static void StaticRegisterNativesUSphereComponent() { NativeCall<void>(nullptr, "USphereComponent.StaticRegisterNativesUSphereComponent"); }

};


struct AActor : UObject

{

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

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

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

    TEnumAsByte<enum ENetRole>& RemoteRoleField() { return *GetNativePointerField<TEnumAsByte<enum ENetRole>*>(this, "AActor.RemoteRole"); }

    AActor* OwnerField() { return *GetNativePointerField<AActor**>(this, "AActor.Owner"); }

    long double& LastReplicatedMovementField() { return *GetNativePointerField<long double*>(this, "AActor.LastReplicatedMovement"); }

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

    TEnumAsByte<enum ENetRole>& RoleField() { return *GetNativePointerField<TEnumAsByte<enum ENetRole>*>(this, "AActor.Role"); }

    TEnumAsByte<enum ENetDormancy>& NetDormancyField() { return *GetNativePointerField<TEnumAsByte<enum ENetDormancy>*>(this, "AActor.NetDormancy"); }

    TArray<TWeakObjectPtr<UActorComponent>>& ReplicatedComponentsField() { return *GetNativePointerField<TArray<TWeakObjectPtr<UActorComponent>>*>(this, "AActor.ReplicatedComponents"); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    char& StasisSetIndexField() { return *GetNativePointerField<char*>(this, "AActor.StasisSetIndex"); }

    char& RandomStartByteField() { return *GetNativePointerField<char*>(this, "AActor.RandomStartByte"); }

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

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

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

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

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

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

    long double& NetUpdateTimeField() { return *GetNativePointerField<long double*>(this, "AActor.NetUpdateTime"); }

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

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

    long double& LastNetUpdateTimeField() { return *GetNativePointerField<long double*>(this, "AActor.LastNetUpdateTime"); }

    FName& NetDriverNameField() { return *GetNativePointerField<FName*>(this, "AActor.NetDriverName"); }

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

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

    APawn* InstigatorField() { return *GetNativePointerField<APawn**>(this, "AActor.Instigator"); }

    long double& CreationTimeField() { return *GetNativePointerField<long double*>(this, "AActor.CreationTime"); }

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

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

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

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

    USceneComponent* RootComponentField() { return *GetNativePointerField<USceneComponent**>(this, "AActor.RootComponent"); }

    TArray<AMatineeActor*> ControllingMatineeActorsField() { return *GetNativePointerField<TArray<AMatineeActor*>*>(this, "AActor.ControllingMatineeActors"); }

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

    TArray<FName>& LayersField() { return *GetNativePointerField<TArray<FName>*>(this, "AActor.Layers"); }

    TWeakObjectPtr<AActor>& ParentComponentActorField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "AActor.ParentComponentActor"); }

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

    long double& LastRenderTimeIgnoreShadowField() { return *GetNativePointerField<long double*>(this, "AActor.LastRenderTimeIgnoreShadow"); }

    TArray<FName>& TagsField() { return *GetNativePointerField<TArray<FName>*>(this, "AActor.Tags"); }

    unsigned __int64& HiddenEditorViewsField() { return *GetNativePointerField<unsigned __int64*>(this, "AActor.HiddenEditorViews"); }

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

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

    FGuid& UniqueGuidIdField() { return *GetNativePointerField<FGuid*>(this, "AActor.UniqueGuidId"); }

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

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

    TArray<UActorComponent*> OwnedComponentsField() { return *GetNativePointerField<TArray<UActorComponent*>*>(this, "AActor.OwnedComponents"); }

    TArray<UActorComponent*> SerializedComponentsField() { return *GetNativePointerField<TArray<UActorComponent*>*>(this, "AActor.SerializedComponents"); }

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


    // Bit fields


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


    // Functions


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

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

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

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

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

    void SetRemoteRoleForBackwardsCompat(ENetRole InRemoteRole) { NativeCall<void, ENetRole>(this, "AActor.SetRemoteRoleForBackwardsCompat", InRemoteRole); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    void RegisterActorTickFunctions(bool bRegister, bool bSaveAndRestoreTickState) { NativeCall<void, bool, bool>(this, "AActor.RegisterActorTickFunctions", bRegister, bSaveAndRestoreTickState); }

    void RegisterAllActorTickFunctions(bool bRegister, bool bDoComponents, bool bSaveAndRestoreTickState) { NativeCall<void, bool, bool, bool>(this, "AActor.RegisterAllActorTickFunctions", bRegister, bDoComponents, bSaveAndRestoreTickState); }

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

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

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

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

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

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

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

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

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

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

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

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

    FBox* GetComponentsBoundingBox(FBox* result, bool bNonColliding) { return NativeCall<FBox*, FBox*, bool>(this, "AActor.GetComponentsBoundingBox", result, bNonColliding); }

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

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

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

    void GetOverlappingActors(TArray<AActor*>* OverlappingActors, UClass* ClassFilter) { NativeCall<void, TArray<AActor*>*, UClass*>(this, "AActor.GetOverlappingActors", OverlappingActors, ClassFilter); }

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

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

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

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

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

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

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

    void DetachRootComponentFromParent(bool bMaintainWorldPosition) { NativeCall<void, bool>(this, "AActor.DetachRootComponentFromParent", bMaintainWorldPosition); }

    void DetachSceneComponentsFromParent(USceneComponent* InParentComponent, bool bMaintainWorldPosition) { NativeCall<void, USceneComponent*, bool>(this, "AActor.DetachSceneComponentsFromParent", InParentComponent, bMaintainWorldPosition); }

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

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

    void GetAttachedActors(TArray<AActor*>* OutActors) { NativeCall<void, TArray<AActor*>*>(this, "AActor.GetAttachedActors", OutActors); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    void MakeNoise(float Loudness, APawn* NoiseInstigator, FVector NoiseLocation) { NativeCall<void, float, APawn*, FVector>(this, "AActor.MakeNoise", Loudness, NoiseInstigator, NoiseLocation); }

    static void MakeNoiseImpl(AActor* NoiseMaker, float Loudness, APawn* NoiseInstigator, FVector* NoiseLocation) { NativeCall<void, AActor*, float, APawn*, FVector*>(nullptr, "AActor.MakeNoiseImpl", NoiseMaker, Loudness, NoiseInstigator, NoiseLocation); }

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

    float InternalTakeRadialDamage(float Damage, FRadialDamageEvent* RadialDamageEvent, AController* EventInstigator, AActor* DamageCauser) { return NativeCall<float, float, FRadialDamageEvent*, AController*, AActor*>(this, "AActor.InternalTakeRadialDamage", Damage, RadialDamageEvent, EventInstigator, DamageCauser); }

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

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

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

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

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

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

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

    void GetActorEyesViewPoint(FVector* OutLocation, FRotator* OutRotation) { NativeCall<void, FVector*, FRotator*>(this, "AActor.GetActorEyesViewPoint", OutLocation, OutRotation); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    void PostSpawnInitialize(FVector* SpawnLocation, FRotator* SpawnRotation, AActor* InOwner, APawn* InInstigator, bool bRemoteOwned, bool bNoFail, bool bDeferConstruction, bool bDeferBeginPlay) { NativeCall<void, FVector*, FRotator*, AActor*, APawn*, bool, bool, bool, bool>(this, "AActor.PostSpawnInitialize", SpawnLocation, SpawnRotation, InOwner, InInstigator, bRemoteOwned, bNoFail, bDeferConstruction, bDeferBeginPlay); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    void SetActorRelativeScale3D(FVector NewRelativeScale) { NativeCall<void, FVector>(this, "AActor.SetActorRelativeScale3D", NewRelativeScale); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    bool ActorLineTraceSingle(FHitResult* OutHit, FVector* Start, FVector* End, ECollisionChannel TraceChannel, FCollisionQueryParams* Params) { return NativeCall<bool, FHitResult*, FVector*, FVector*, ECollisionChannel, FCollisionQueryParams*>(this, "AActor.ActorLineTraceSingle", OutHit, Start, End, TraceChannel, Params); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    void SendExecCommand(FName CommandName, FNetExecParams* ExecParams, bool bIsReliable) { NativeCall<void, FName, FNetExecParams*, bool>(this, "AActor.SendExecCommand", CommandName, ExecParams, bIsReliable); }

    void ServerSendSimpleExecCommandToEveryone(FName CommandName, bool bIsReliable, bool bForceSendToLocalPlayer, bool bIgnoreRelevancy) { NativeCall<void, FName, bool, bool, bool>(this, "AActor.ServerSendSimpleExecCommandToEveryone", CommandName, bIsReliable, bForceSendToLocalPlayer, bIgnoreRelevancy); }

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

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

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

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

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

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

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

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

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

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

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

    void ActorPlaySound_Implementation(USoundBase* SoundAsset, bool bAttach, FName BoneName, FVector LocOffset) { NativeCall<void, USoundBase*, bool, FName, FVector>(this, "AActor.ActorPlaySound_Implementation", SoundAsset, bAttach, BoneName, LocOffset); }

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

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

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

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

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

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

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

    UActorComponent* AddComponent(FName TemplateName, bool bManualAttachment, FTransform* RelativeTransform, UObject* ComponentTemplateContext) { return NativeCall<UActorComponent*, FName, bool, FTransform*, UObject*>(this, "AActor.AddComponent", TemplateName, bManualAttachment, RelativeTransform, ComponentTemplateContext); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    void ActorPlaySound(USoundBase* SoundAsset, bool bAttach, FName BoneName, FVector LocOffset) { NativeCall<void, USoundBase*, bool, FName, FVector>(this, "AActor.ActorPlaySound", SoundAsset, bAttach, BoneName, LocOffset); }

    void ActorPlaySoundUnreliable(USoundBase* SoundAsset, bool bAttach, FName BoneName, FVector LocOffset) { NativeCall<void, USoundBase*, bool, FName, FVector>(this, "AActor.ActorPlaySoundUnreliable", SoundAsset, bAttach, BoneName, LocOffset); }

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

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

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

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

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

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

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

    bool BPConsumeSetPinCode(APlayerController* ForPC, int appledPinCode, bool bIsSetting, int TheCustomIndex) { return NativeCall<bool, APlayerController*, int, bool, int>(this, "AActor.BPConsumeSetPinCode", ForPC, appledPinCode, bIsSetting, TheCustomIndex); }

    bool BPConsumeUsePinCode(AActor* FromKeypadActor, APlayerController* ForPC, int appledPinCode, bool bIsActivating) { return NativeCall<bool, AActor*, APlayerController*, int, bool>(this, "AActor.BPConsumeUsePinCode", FromKeypadActor, ForPC, appledPinCode, bIsActivating); }

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

    int BPGetExtraSpecialBlueprintInt() { return NativeCall<int>(this, "AActor.BPGetExtraSpecialBlueprintInt"); }

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

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

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

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

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

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

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

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

    void ModifyHudMultiUseLoc(FVector2D* theVec, APlayerController* PC, int index) { NativeCall<void, FVector2D*, APlayerController*, int>(this, "AActor.ModifyHudMultiUseLoc", theVec, PC, index); }

    void MulticastDrawDebugArrow(FVector LineStart, FVector LineEnd, float ArrowSize, FLinearColor LineColor, float Duration, bool enableInShipping) { NativeCall<void, FVector, FVector, float, FLinearColor, float, bool>(this, "AActor.MulticastDrawDebugArrow", LineStart, LineEnd, ArrowSize, LineColor, Duration, enableInShipping); }

    void MulticastDrawDebugBox(FVector Center, FVector Extent, FLinearColor LineColor, FRotator Rotation, float Duration, bool enableInShipping) { NativeCall<void, FVector, FVector, FLinearColor, FRotator, float, bool>(this, "AActor.MulticastDrawDebugBox", Center, Extent, LineColor, Rotation, Duration, enableInShipping); }

    void MulticastDrawDebugCapsule(FVector Center, float HalfHeight, float Radius, FRotator Rotation, FLinearColor LineColor, float Duration, bool enableInShipping) { NativeCall<void, FVector, float, float, FRotator, FLinearColor, float, bool>(this, "AActor.MulticastDrawDebugCapsule", Center, HalfHeight, Radius, Rotation, LineColor, Duration, enableInShipping); }

    void MulticastDrawDebugCapsuleWithExtents(FVector Top, FVector Bottom, float Radius, FLinearColor LineColor, float Duration, bool bPersistent) { NativeCall<void, FVector, FVector, float, FLinearColor, float, bool>(this, "AActor.MulticastDrawDebugCapsuleWithExtents", Top, Bottom, Radius, LineColor, Duration, bPersistent); }

    void MulticastDrawDebugCoordinateSystem(FVector AxisLoc, FRotator AxisRot, float Scale, float Duration, float Thickness) { NativeCall<void, FVector, FRotator, float, float, float>(this, "AActor.MulticastDrawDebugCoordinateSystem", AxisLoc, AxisRot, Scale, Duration, Thickness); }

    void MulticastDrawDebugCylinder(FVector Start, FVector End, float Radius, int Segments, FLinearColor LineColor, float Duration) { NativeCall<void, FVector, FVector, float, int, FLinearColor, float>(this, "AActor.MulticastDrawDebugCylinder", Start, End, Radius, Segments, LineColor, Duration); }

    void MulticastDrawDebugLine(FVector LineStart, FVector LineEnd, FLinearColor LineColor, float Duration, float Thickness, bool enableInShipping) { NativeCall<void, FVector, FVector, FLinearColor, float, float, bool>(this, "AActor.MulticastDrawDebugLine", LineStart, LineEnd, LineColor, Duration, Thickness, enableInShipping); }

    void MulticastDrawDebugPoint(FVector Position, float Size, FLinearColor PointColor, float Duration, bool enableInShipping) { NativeCall<void, FVector, float, FLinearColor, float, bool>(this, "AActor.MulticastDrawDebugPoint", Position, Size, PointColor, Duration, enableInShipping); }

    void MulticastDrawDebugSphere(FVector Center, float Radius, int Segments, FLinearColor LineColor, float Duration, bool enableInShipping) { NativeCall<void, FVector, float, int, FLinearColor, float, bool>(this, "AActor.MulticastDrawDebugSphere", Center, Radius, Segments, LineColor, Duration, enableInShipping); }

    void MulticastDrawDebugString(FVector TextLocation, FString* Text, AActor* TestBaseActor, FLinearColor TextColor, float Duration, bool enableInShipping) { NativeCall<void, FVector, FString*, AActor*, FLinearColor, float, bool>(this, "AActor.MulticastDrawDebugString", TextLocation, Text, TestBaseActor, TextColor, Duration, enableInShipping); }

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

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

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

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

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

    void ReceiveActorBeginOverlap(AActor* OtherActor) { NativeCall<void, AActor*>(this, "AActor.ReceiveActorBeginOverlap", OtherActor); }

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

    void ReceiveActorEndOverlap(AActor* OtherActor) { NativeCall<void, AActor*>(this, "AActor.ReceiveActorEndOverlap", OtherActor); }

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

    void ReceiveActorOnInputTouchBegin(ETouchIndex::Type FingerIndex) { NativeCall<void, ETouchIndex::Type>(this, "AActor.ReceiveActorOnInputTouchBegin", FingerIndex); }

    void ReceiveActorOnInputTouchEnd(ETouchIndex::Type FingerIndex) { NativeCall<void, ETouchIndex::Type>(this, "AActor.ReceiveActorOnInputTouchEnd", FingerIndex); }

    void ReceiveActorOnInputTouchEnter(ETouchIndex::Type FingerIndex) { NativeCall<void, ETouchIndex::Type>(this, "AActor.ReceiveActorOnInputTouchEnter", FingerIndex); }

    void ReceiveActorOnInputTouchLeave(ETouchIndex::Type FingerIndex) { NativeCall<void, ETouchIndex::Type>(this, "AActor.ReceiveActorOnInputTouchLeave", FingerIndex); }

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

    void ReceiveAnyDamage(float Damage, UDamageType* DamageType, AController* InstigatedBy, AActor* DamageCauser) { NativeCall<void, float, UDamageType*, AController*, AActor*>(this, "AActor.ReceiveAnyDamage", Damage, DamageType, InstigatedBy, DamageCauser); }

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

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

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

    void ReceiveHit(UPrimitiveComponent* MyComp, AActor* Other, UPrimitiveComponent* OtherComp, bool bSelfMoved, FVector HitLocation, FVector HitNormal, FVector NormalImpulse, FHitResult* Hit) { NativeCall<void, UPrimitiveComponent*, AActor*, UPrimitiveComponent*, bool, FVector, FVector, FVector, FHitResult*>(this, "AActor.ReceiveHit", MyComp, Other, OtherComp, bSelfMoved, HitLocation, HitNormal, NormalImpulse, Hit); }

    void ReceiveInput(FString* InputName, float Value, FVector VectorValue, bool bStarted, bool bEnded) { NativeCall<void, FString*, float, FVector, bool, bool>(this, "AActor.ReceiveInput", InputName, Value, VectorValue, bStarted, bEnded); }

    void ReceivePointDamage(float Damage, UDamageType* DamageType, FVector HitLocation, FVector HitNormal, UPrimitiveComponent* HitComponent, FName BoneName, FVector ShotFromDirection, AController* InstigatedBy, AActor* DamageCauser) { NativeCall<void, float, UDamageType*, FVector, FVector, UPrimitiveComponent*, FName, FVector, AController*, AActor*>(this, "AActor.ReceivePointDamage", Damage, DamageType, HitLocation, HitNormal, HitComponent, BoneName, ShotFromDirection, InstigatedBy, DamageCauser); }

    void ReceiveRadialDamage(float DamageReceived, UDamageType* DamageType, FVector Origin, FHitResult* HitInfo, AController* InstigatedBy, AActor* DamageCauser) { NativeCall<void, float, UDamageType*, FVector, FHitResult*, AController*, AActor*>(this, "AActor.ReceiveRadialDamage", DamageReceived, DamageType, Origin, HitInfo, InstigatedBy, DamageCauser); }

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

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

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

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

};


struct AInfo : AActor

{


    // Functions


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

};


struct APawn : AActor

{

    float& BaseEyeHeightField() { return *GetNativePointerField<float*>(this, "APawn.BaseEyeHeight"); }

    TSubclassOf<AController> & AIControllerClassField() { return *GetNativePointerField<TSubclassOf<AController>*>(this, "APawn.AIControllerClass"); }

    APlayerState * PlayerStateField() { return *GetNativePointerField<APlayerState**>(this, "APawn.PlayerState"); }

    char& RemoteViewPitchField() { return *GetNativePointerField<char*>(this, "APawn.RemoteViewPitch"); }

    AController * LastHitByField() { return *GetNativePointerField<AController**>(this, "APawn.LastHitBy"); }

    AController * ControllerField() { return *GetNativePointerField<AController**>(this, "APawn.Controller"); }

    float& AllowedYawErrorField() { return *GetNativePointerField<float*>(this, "APawn.AllowedYawError"); }

    bool& bClearOnConsumeField() { return *GetNativePointerField<bool*>(this, "APawn.bClearOnConsume"); }

    TWeakObjectPtr<AActor> & TetherActorField() { return *GetNativePointerField<TWeakObjectPtr<AActor>*>(this, "APawn.TetherActor"); }

    float& TetherRadiusField() { return *GetNativePointerField<float*>(this, "APawn.TetherRadius"); }

    float& TetherHeightField() { return *GetNativePointerField<float*>(this, "APawn.TetherHeight"); }

    FVector & ControlInputVectorField() { return *GetNativePointerField<FVector*>(this, "APawn.ControlInputVector"); }

    FVector & LastControlInputVectorField() { return *GetNativePointerField<FVector*>(this, "APawn.LastControlInputVector"); }

    TWeakObjectPtr<AController> & SpawnedForControllerField() { return *GetNativePointerField<TWeakObjectPtr<AController>*>(this, "APawn.SpawnedForController"); }


    // Bit fields


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

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

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

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

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

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

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


    // Functions


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    bool ShouldTakeDamage(float Damage, FDamageEvent * DamageEvent, AController * EventInstigator, AActor * DamageCauser) { return NativeCall<bool, float, FDamageEvent*, AController*, AActor*>(this, "APawn.ShouldTakeDamage", Damage, DamageEvent, EventInstigator, DamageCauser); }

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

    AController * GetCharacterController() { return NativeCall<AController*>(this, "APawn.GetCharacterController"); }

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

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

    void PossessedBy(AController * NewController) { NativeCall<void, AController*>(this, "APawn.PossessedBy", NewController); }

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

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

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

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

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

    void SetMovementTether(AActor * InTetherActor, float Radius, float Height) { NativeCall<void, AActor*, float, float>(this, "APawn.SetMovementTether", InTetherActor, Radius, Height); }

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

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

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

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

    bool IsTargetWithinTether(FVector * Destination, float AdditionalRadius) { return NativeCall<bool, FVector*, float>(this, "APawn.IsTargetWithinTether", Destination, AdditionalRadius); }

    FVector * GetTetheredDestination(FVector * result, FVector * Destination, float AdditionalRadius) { return NativeCall<FVector*, FVector*, FVector*, float>(this, "APawn.GetTetheredDestination", result, Destination, AdditionalRadius); }

    FVector * GetTetheredVelocity(FVector * result, FVector * RequestedVelocity, float DeltaSeconds) { return NativeCall<FVector*, FVector*, FVector*, float>(this, "APawn.GetTetheredVelocity", result, RequestedVelocity, DeltaSeconds); }

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

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

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

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

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

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

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

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

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

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

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

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

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

    void GetActorEyesViewPoint(FVector * out_Location, FRotator * out_Rotation) { NativeCall<void, FVector*, FRotator*>(this, "APawn.GetActorEyesViewPoint", out_Location, out_Rotation); }

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

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

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

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

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

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

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

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

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

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

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

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

    void PostNetReceiveVelocity(FVector * NewVelocity) { NativeCall<void, FVector*>(this, "APawn.PostNetReceiveVelocity", NewVelocity); }

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

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

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

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

    void PawnMakeNoise(float Loudness, FVector NoiseLocation, bool bUseNoiseMakerLocation, AActor * NoiseMaker) { NativeCall<void, float, FVector, bool, AActor*>(this, "APawn.PawnMakeNoise", Loudness, NoiseLocation, bUseNoiseMakerLocation, NoiseMaker); }

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

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

    static void StaticRegisterNativesAPawn() { NativeCall<void>(nullptr, "APawn.StaticRegisterNativesAPawn"); }

    void InterceptInputEvent(FString * InputName) { NativeCall<void, FString*>(this, "APawn.InterceptInputEvent", InputName); }

};


struct UCheatManager : UObject

{

    float& DebugTraceDistanceField() { return *GetNativePointerField<float*>(this, "UCheatManager.DebugTraceDistance"); }

    float& DebugCapsuleHalfHeightField() { return *GetNativePointerField<float*>(this, "UCheatManager.DebugCapsuleHalfHeight"); }

    float& DebugCapsuleRadiusField() { return *GetNativePointerField<float*>(this, "UCheatManager.DebugCapsuleRadius"); }

    float& DebugTraceDrawNormalLengthField() { return *GetNativePointerField<float*>(this, "UCheatManager.DebugTraceDrawNormalLength"); }

    TEnumAsByte<enum ECollisionChannel>& DebugTraceChannelField() { return *GetNativePointerField<TEnumAsByte<enum ECollisionChannel>*>(this, "UCheatManager.DebugTraceChannel"); }

    int& CurrentTraceIndexField() { return *GetNativePointerField<int*>(this, "UCheatManager.CurrentTraceIndex"); }

    int& CurrentTracePawnIndexField() { return *GetNativePointerField<int*>(this, "UCheatManager.CurrentTracePawnIndex"); }

    float& DumpAILogsIntervalField() { return *GetNativePointerField<float*>(this, "UCheatManager.DumpAILogsInterval"); }


    // Bit fields


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

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

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

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


    // Functions


    void FreezeFrame(float delay) { NativeCall<void, float>(this, "UCheatManager.FreezeFrame", delay); }

    void Teleport() { NativeCall<void>(this, "UCheatManager.Teleport"); }

    void ChangeSize(float F) { NativeCall<void, float>(this, "UCheatManager.ChangeSize", F); }

    void Fly() { NativeCall<void>(this, "UCheatManager.Fly"); }

    void Walk() { NativeCall<void>(this, "UCheatManager.Walk"); }

    void Ghost() { NativeCall<void>(this, "UCheatManager.Ghost"); }

    void God() { NativeCall<void>(this, "UCheatManager.God"); }

    void Slomo(float T) { NativeCall<void, float>(this, "UCheatManager.Slomo", T); }

    void DamageTarget(float DamageAmount) { NativeCall<void, float>(this, "UCheatManager.DamageTarget", DamageAmount); }

    void DestroyTarget() { NativeCall<void>(this, "UCheatManager.DestroyTarget"); }

    void DestroyAll(TSubclassOf<AActor> aClass) { NativeCall<void, TSubclassOf<AActor>>(this, "UCheatManager.DestroyAll", aClass); }

    void DestroyPawns(TSubclassOf<APawn> aClass) { NativeCall<void, TSubclassOf<APawn>>(this, "UCheatManager.DestroyPawns", aClass); }

    void Summon(FString* ClassName) { NativeCall<void, FString*>(this, "UCheatManager.Summon", ClassName); }

    void PlayersOnly() { NativeCall<void>(this, "UCheatManager.PlayersOnly"); }

    void ViewSelf() { NativeCall<void>(this, "UCheatManager.ViewSelf"); }

    void ViewPlayer(FString* S) { NativeCall<void, FString*>(this, "UCheatManager.ViewPlayer", S); }

    void ViewActor(FName ActorName) { NativeCall<void, FName>(this, "UCheatManager.ViewActor", ActorName); }

    void ViewClass(TSubclassOf<AActor> DesiredClass) { NativeCall<void, TSubclassOf<AActor>>(this, "UCheatManager.ViewClass", DesiredClass); }

    void SetLevelStreamingStatus(FName PackageName, bool bShouldBeLoaded, bool bShouldBeVisible) { NativeCall<void, FName, bool, bool>(this, "UCheatManager.SetLevelStreamingStatus", PackageName, bShouldBeLoaded, bShouldBeVisible); }

    void StreamLevelIn(FName PackageName) { NativeCall<void, FName>(this, "UCheatManager.StreamLevelIn", PackageName); }

    void OnlyLoadLevel(FName PackageName) { NativeCall<void, FName>(this, "UCheatManager.OnlyLoadLevel", PackageName); }

    void StreamLevelOut(FName PackageName) { NativeCall<void, FName>(this, "UCheatManager.StreamLevelOut", PackageName); }

    void ToggleDebugCamera() { NativeCall<void>(this, "UCheatManager.ToggleDebugCamera"); }

    void EnableDebugCamera() { NativeCall<void>(this, "UCheatManager.EnableDebugCamera"); }

    void DisableDebugCamera() { NativeCall<void>(this, "UCheatManager.DisableDebugCamera"); }

    void DebugCapsuleSweep() { NativeCall<void>(this, "UCheatManager.DebugCapsuleSweep"); }

    void DebugCapsuleSweepSize(float HalfHeight, float Radius) { NativeCall<void, float, float>(this, "UCheatManager.DebugCapsuleSweepSize", HalfHeight, Radius); }

    void DebugCapsuleSweepChannel(ECollisionChannel Channel) { NativeCall<void, ECollisionChannel>(this, "UCheatManager.DebugCapsuleSweepChannel", Channel); }

    void DebugCapsuleSweepComplex(bool bTraceComplex) { NativeCall<void, bool>(this, "UCheatManager.DebugCapsuleSweepComplex", bTraceComplex); }

    void DebugCapsuleSweepCapture() { NativeCall<void>(this, "UCheatManager.DebugCapsuleSweepCapture"); }

    void DebugCapsuleSweepPawn() { NativeCall<void>(this, "UCheatManager.DebugCapsuleSweepPawn"); }

    void DebugCapsuleSweepClear() { NativeCall<void>(this, "UCheatManager.DebugCapsuleSweepClear"); }

    void TestCollisionDistance() { NativeCall<void>(this, "UCheatManager.TestCollisionDistance"); }

    void WidgetReflector() { NativeCall<void>(this, "UCheatManager.WidgetReflector"); }

    void RebuildNavigation() { NativeCall<void>(this, "UCheatManager.RebuildNavigation"); }

    void DumpOnlineSessionState() { NativeCall<void>(this, "UCheatManager.DumpOnlineSessionState"); }

    void DumpVoiceMutingState() { NativeCall<void>(this, "UCheatManager.DumpVoiceMutingState"); }

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

    void BugItGo(float X, float Y, float Z, float Pitch, float Yaw, float Roll) { NativeCall<void, float, float, float, float, float, float>(this, "UCheatManager.BugItGo", X, Y, Z, Pitch, Yaw, Roll); }

    void BugItGoString(FString* TheLocation, FString* TheRotation) { NativeCall<void, FString*, FString*>(this, "UCheatManager.BugItGoString", TheLocation, TheRotation); }

    void BugItWorker(FVector TheLocation, FRotator TheRotation) { NativeCall<void, FVector, FRotator>(this, "UCheatManager.BugItWorker", TheLocation, TheRotation); }

    void BugIt(FString* ScreenShotDescription) { NativeCall<void, FString*>(this, "UCheatManager.BugIt", ScreenShotDescription); }

    void BugItStringCreator(FVector ViewLocation, FRotator ViewRotation, FString* GoString, FString* LocString) { NativeCall<void, FVector, FRotator, FString*, FString*>(this, "UCheatManager.BugItStringCreator", ViewLocation, ViewRotation, GoString, LocString); }

    void FlushLog() { NativeCall<void>(this, "UCheatManager.FlushLog"); }

    void LogLoc() { NativeCall<void>(this, "UCheatManager.LogLoc"); }

    void SetWorldOrigin() { NativeCall<void>(this, "UCheatManager.SetWorldOrigin"); }

    static void StaticRegisterNativesUCheatManager() { NativeCall<void>(nullptr, "UCheatManager.StaticRegisterNativesUCheatManager"); }

    void ServerToggleAILogging() { NativeCall<void>(this, "UCheatManager.ServerToggleAILogging"); }

};


struct UShooterCheatManager : UCheatManager

{

    bool& bIsRCONCheatManagerField() { return *GetNativePointerField<bool*>(this, "UShooterCheatManager.bIsRCONCheatManager"); }

    AShooterPlayerController* MyPCField() { return *GetNativePointerField<AShooterPlayerController**>(this, "UShooterCheatManager.MyPC"); }


    // Functions


    void TakeAllStructure() { NativeCall<void>(this, "UShooterCheatManager.TakeAllStructure"); }

    void TakeAllDino() { NativeCall<void>(this, "UShooterCheatManager.TakeAllDino"); }

    void TakeTribe(int TribeTeamID) { NativeCall<void, int>(this, "UShooterCheatManager.TakeTribe", TribeTeamID); }

    void GMBuff() { NativeCall<void>(this, "UShooterCheatManager.GMBuff"); }

    void GMSummon(FString* ClassName, int Level) { NativeCall<void, FString*, int>(this, "UShooterCheatManager.GMSummon", ClassName, Level); }

    void ClearMyBuffs() { NativeCall<void>(this, "UShooterCheatManager.ClearMyBuffs"); }

    void ListMyBuffs() { NativeCall<void>(this, "UShooterCheatManager.ListMyBuffs"); }

    void ListMyTargetBuffs() { NativeCall<void>(this, "UShooterCheatManager.ListMyTargetBuffs"); }

    FString* ListBuffs(FString* result, APrimalCharacter* target) { return NativeCall<FString*, FString*, APrimalCharacter*>(this, "UShooterCheatManager.ListBuffs", result, target); }

    void DebugCompanionReactions() { NativeCall<void>(this, "UShooterCheatManager.DebugCompanionReactions"); }

    void DebugCompanionAsyncLoadedFiles() { NativeCall<void>(this, "UShooterCheatManager.DebugCompanionAsyncLoadedFiles"); }

    void ClearCryoSickness() { NativeCall<void>(this, "UShooterCheatManager.ClearCryoSickness"); }

    void Broadcast(FString* MessageText) { NativeCall<void, FString*>(this, "UShooterCheatManager.Broadcast", MessageText); }

    void AllowPlayerToJoinNoCheck(FString* SteamId) { NativeCall<void, FString*>(this, "UShooterCheatManager.AllowPlayerToJoinNoCheck", SteamId); }

    void RenameTribe(FString* TribeName, FString* NewName) { NativeCall<void, FString*, FString*>(this, "UShooterCheatManager.RenameTribe", TribeName, NewName); }

    void RenameTribeID(int TribeID, FString* NewName) { NativeCall<void, int, FString*>(this, "UShooterCheatManager.RenameTribeID", TribeID, NewName); }

    void RenamePlayer(FString* PlayerName, FString* NewName) { NativeCall<void, FString*, FString*>(this, "UShooterCheatManager.RenamePlayer", PlayerName, NewName); }

    void RenamePlayerId(int PlayerID, FString* NewName) { NativeCall<void, int, FString*>(this, "UShooterCheatManager.RenamePlayerId", PlayerID, NewName); }

    void DestroyActors(FString* ClassName) { NativeCall<void, FString*>(this, "UShooterCheatManager.DestroyActors", ClassName); }

    void DestroyWildDinoClasses(FString* ClassName) { NativeCall<void, FString*>(this, "UShooterCheatManager.DestroyWildDinoClasses", ClassName); }

    void SetGraphicsQuality(int val) { NativeCall<void, int>(this, "UShooterCheatManager.SetGraphicsQuality", val); }

    void SaveWorld() { NativeCall<void>(this, "UShooterCheatManager.SaveWorld"); }

    void StartSaveBackup() { NativeCall<void>(this, "UShooterCheatManager.StartSaveBackup"); }

    void DoExit() { NativeCall<void>(this, "UShooterCheatManager.DoExit"); }

    void OpenMap(FString* MapName) { NativeCall<void, FString*>(this, "UShooterCheatManager.OpenMap", MapName); }

    void DoRestartLevel() { NativeCall<void>(this, "UShooterCheatManager.DoRestartLevel"); }

    void SetGlobalPause(bool bIsPaused) { NativeCall<void, bool>(this, "UShooterCheatManager.SetGlobalPause", bIsPaused); }

    void DisallowPlayerToJoinNoCheck(FString* SteamId) { NativeCall<void, FString*>(this, "UShooterCheatManager.DisallowPlayerToJoinNoCheck", SteamId); }

    void CamZoomIn() { NativeCall<void>(this, "UShooterCheatManager.CamZoomIn"); }

    void CamZoomOut() { NativeCall<void>(this, "UShooterCheatManager.CamZoomOut"); }

    void OnToggleInGameMenu() { NativeCall<void>(this, "UShooterCheatManager.OnToggleInGameMenu"); }

    void GiveResources() { NativeCall<void>(this, "UShooterCheatManager.GiveResources"); }

    void GiveEngrams() { NativeCall<void>(this, "UShooterCheatManager.GiveEngrams"); }

    void GiveEngramsTekOnly() { NativeCall<void>(this, "UShooterCheatManager.GiveEngramsTekOnly"); }

    bool SetCreativeModeOnPawn(AShooterCharacter* Pawn, bool bCreativeMode) { return NativeCall<bool, AShooterCharacter*, bool>(this, "UShooterCheatManager.SetCreativeModeOnPawn", Pawn, bCreativeMode); }

    void GiveCreativeMode() { NativeCall<void>(this, "UShooterCheatManager.GiveCreativeMode"); }

    void GCM() { NativeCall<void>(this, "UShooterCheatManager.GCM"); }

    void DeepPockets() { NativeCall<void>(this, "UShooterCheatManager.DeepPockets"); }

    void InfiniteWeight() { NativeCall<void>(this, "UShooterCheatManager.InfiniteWeight"); }

    void GiveCreativeModeToTarget() { NativeCall<void>(this, "UShooterCheatManager.GiveCreativeModeToTarget"); }

    void GCMT() { NativeCall<void>(this, "UShooterCheatManager.GCMT"); }

    void GlobalObjectCount() { NativeCall<void>(this, "UShooterCheatManager.GlobalObjectCount"); }

    void GiveCreativeModeToPlayer(__int64 PlayerID) { NativeCall<void, __int64>(this, "UShooterCheatManager.GiveCreativeModeToPlayer", PlayerID); }

    void GCMP(__int64 PlayerID) { NativeCall<void, __int64>(this, "UShooterCheatManager.GCMP", PlayerID); }

    void ForceTribes(FString* PlayerName1, FString* PlayerName2, FString* NewTribeName) { NativeCall<void, FString*, FString*, FString*>(this, "UShooterCheatManager.ForceTribes", PlayerName1, PlayerName2, NewTribeName); }

    void ShowInGameMenu() { NativeCall<void>(this, "UShooterCheatManager.ShowInGameMenu"); }

    void AddExperienceToTarget(float HowMuch, bool fromTribeShare, bool bPreventSharingWithTribe) { NativeCall<void, float, bool, bool>(this, "UShooterCheatManager.AddExperienceToTarget", HowMuch, fromTribeShare, bPreventSharingWithTribe); }

    void AddExperience(float HowMuch, bool fromTribeShare, bool bPreventSharingWithTribe) { NativeCall<void, float, bool, bool>(this, "UShooterCheatManager.AddExperience", HowMuch, fromTribeShare, bPreventSharingWithTribe); }

    void LevelUp(FName statName, int numLevels) { NativeCall<void, FName, int>(this, "UShooterCheatManager.LevelUp", statName, numLevels); }

    void SetStatOnTarget(FName StatName, float value) { NativeCall<void, FName, float>(this, "UShooterCheatManager.SetStatOnTarget", StatName, value); }

    void LevelUpAOE(FName statName, float Radius, int numLevels) { NativeCall<void, FName, float, int>(this, "UShooterCheatManager.LevelUpAOE", statName, Radius, numLevels); }

    void LevelUpTarget(FName StatName, int NumLevels) { NativeCall<void, FName, int>(this, "UShooterCheatManager.LevelUpTarget", StatName, NumLevels); }

    void LevelUpInternal(APrimalCharacter* character, FName statName, int numLevels) { NativeCall<void, APrimalCharacter*, FName, int>(this, "UShooterCheatManager.LevelUpInternal", character, statName, numLevels); }

    void GiveExpToPlayer(__int64 PlayerID, float HowMuch, bool fromTribeShare, bool bPreventSharingWithTribe) { NativeCall<void, __int64, float, bool, bool>(this, "UShooterCheatManager.GiveExpToPlayer", PlayerID, HowMuch, fromTribeShare, bPreventSharingWithTribe); }

    void GiveTekEngramsTo(__int64 PlayerID, FName* blueprintPath) { NativeCall<void, __int64, FName*>(this, "UShooterCheatManager.GiveTekEngramsTo", PlayerID, blueprintPath); }

    void GiveExpToTarget(float HowMuch, bool fromTribeShare, bool bPreventSharingWithTribe) { NativeCall<void, float, bool, bool>(this, "UShooterCheatManager.GiveExpToTarget", HowMuch, fromTribeShare, bPreventSharingWithTribe); }

    void DebugMyTarget() { NativeCall<void>(this, "UShooterCheatManager.DebugMyTarget"); }

    void DebugMyTargetFromLocation(FVector* spectatorLocation, FRotator* rotator) { NativeCall<void, FVector*, FRotator*>(this, "UShooterCheatManager.DebugMyTargetFromLocation", spectatorLocation, rotator); }

    void DebugMyTargetPrint(AActor* actor) { NativeCall<void, AActor*>(this, "UShooterCheatManager.DebugMyTargetPrint", actor); }

    void DestroyMyTarget() { NativeCall<void>(this, "UShooterCheatManager.DestroyMyTarget"); }

    void SetMyTargetSleeping(bool bIsSleeping) { NativeCall<void, bool>(this, "UShooterCheatManager.SetMyTargetSleeping", bIsSleeping); }

    void SetTargetDinoColor(int ColorRegion, int ColorID) { NativeCall<void, int, int>(this, "UShooterCheatManager.SetTargetDinoColor", ColorRegion, ColorID); }

    void Kill() { NativeCall<void>(this, "UShooterCheatManager.Kill"); }

    void KillAOETribe(FName Category, float Radius, int TribeID) { NativeCall<void, FName, float, int>(this, "UShooterCheatManager.KillAOETribe", Category, Radius, TribeID); }

    void KillAOE(FName Category, float Radius) { NativeCall<void, FName, float>(this, "UShooterCheatManager.KillAOE", Category, Radius); }

    void Mission(FName CheatName, float Value) { NativeCall<void, FName, float>(this, "UShooterCheatManager.Mission", CheatName, Value); }

    void Dino(FName CheatName) { NativeCall<void, FName>(this, "UShooterCheatManager.Dino", CheatName); }

    void DinoSet(FName CheatName, float Value) { NativeCall<void, FName, float>(this, "UShooterCheatManager.DinoSet", CheatName, Value); }

    void SetNetworkTime(float NewTime) { NativeCall<void, float>(this, "UShooterCheatManager.SetNetworkTime", NewTime); }

    void SetDifficultyValue(float Value) { NativeCall<void, float>(this, "UShooterCheatManager.SetDifficultyValue", Value); }

    TArray<TSubclassOf<AMissionType>>* FuzzyMissionSearch(TArray<TSubclassOf<AMissionType>>* result, FString* MissionTag) { return NativeCall<TArray<TSubclassOf<AMissionType>>*, TArray<TSubclassOf<AMissionType>>*, FString*>(this, "UShooterCheatManager.FuzzyMissionSearch", result, MissionTag); }

    void StartMission(FName MissionTag) { NativeCall<void, FName>(this, "UShooterCheatManager.StartMission", MissionTag); }

    void ForceStartMission(FName MissionTag) { NativeCall<void, FName>(this, "UShooterCheatManager.ForceStartMission", MissionTag); }

    void LeaveMission() { NativeCall<void>(this, "UShooterCheatManager.LeaveMission"); }

    void CompleteMission() { NativeCall<void>(this, "UShooterCheatManager.CompleteMission"); }

    void DeactivateMission() { NativeCall<void>(this, "UShooterCheatManager.DeactivateMission"); }

    void SetActiveMissionDebugFlags(int DebugFlags) { NativeCall<void, int>(this, "UShooterCheatManager.SetActiveMissionDebugFlags", DebugFlags); }

    void ShowActiveMissions() { NativeCall<void>(this, "UShooterCheatManager.ShowActiveMissions"); }

    void KillPlayer(__int64 PlayerID) { NativeCall<void, __int64>(this, "UShooterCheatManager.KillPlayer", PlayerID); }

    void TeleportPlayerIDToMe(__int64 PlayerID) { NativeCall<void, __int64>(this, "UShooterCheatManager.TeleportPlayerIDToMe", PlayerID); }

    void TeleportPlayerNameToMe(FString* PlayerName) { NativeCall<void, FString*>(this, "UShooterCheatManager.TeleportPlayerNameToMe", PlayerName); }

    void TeleportToPlayer(__int64 PlayerID) { NativeCall<void, __int64>(this, "UShooterCheatManager.TeleportToPlayer", PlayerID); }

    void TeleportToPlayerName(FString* PlayerName) { NativeCall<void, FString*>(this, "UShooterCheatManager.TeleportToPlayerName", PlayerName); }

    void TPName(FString* PlayerName) { NativeCall<void, FString*>(this, "UShooterCheatManager.TPName", PlayerName); }

    void DestroyTribePlayers() { NativeCall<void>(this, "UShooterCheatManager.DestroyTribePlayers"); }

    void DestroyTribeIdPlayers(int TribeTeamID) { NativeCall<void, int>(this, "UShooterCheatManager.DestroyTribeIdPlayers", TribeTeamID); }

    void DestroyTribeDinos() { NativeCall<void>(this, "UShooterCheatManager.DestroyTribeDinos"); }

    void DestroyTribeIdDinos(int TribeTeamID) { NativeCall<void, int>(this, "UShooterCheatManager.DestroyTribeIdDinos", TribeTeamID); }

    void DestroyAllTames() { NativeCall<void>(this, "UShooterCheatManager.DestroyAllTames"); }

    void DestroyTribeStructures() { NativeCall<void>(this, "UShooterCheatManager.DestroyTribeStructures"); }

    void DestroyTribeIdStructures(int TribeTeamID) { NativeCall<void, int>(this, "UShooterCheatManager.DestroyTribeIdStructures", TribeTeamID); }

    void DestroyTribeId(int TribeTeamID) { NativeCall<void, int>(this, "UShooterCheatManager.DestroyTribeId", TribeTeamID); }

    void DestroyTribeStructuresLessThan(int TribeTeamID, int Connections, bool includeContainers) { NativeCall<void, int, int, bool>(this, "UShooterCheatManager.DestroyTribeStructuresLessThan", TribeTeamID, Connections, includeContainers); }

    void TribeMessage(int TribeTeamID, FString Message) { NativeCall<void, int, FString>(this, "UShooterCheatManager.TribeMessage", TribeTeamID, Message); }

    void ForcePlayerToJoinTargetTribe(__int64 PlayerID) { NativeCall<void, __int64>(this, "UShooterCheatManager.ForcePlayerToJoinTargetTribe", PlayerID); }

    void ForcePoop() { NativeCall<void>(this, "UShooterCheatManager.ForcePoop"); }

    void ForceJoinTribe() { NativeCall<void>(this, "UShooterCheatManager.ForceJoinTribe"); }

    void ForcePlayerToJoinTribe(__int64 PlayerID, FString TribeName) { NativeCall<void, __int64, FString>(this, "UShooterCheatManager.ForcePlayerToJoinTribe", PlayerID, TribeName); }

    void ForcePlayerToJoinTribeId(__int64 PlayerID, int TribeTeamID) { NativeCall<void, __int64, int>(this, "UShooterCheatManager.ForcePlayerToJoinTribeId", PlayerID, TribeTeamID); }

    void JoinTribe(__int64 PlayerID, int TribeTeamID) { NativeCall<void, __int64, int>(this, "UShooterCheatManager.JoinTribe", PlayerID, TribeTeamID); }

    void SpawnActor(FString* blueprintPath, float spawnDistance, float spawnYOffset, float ZOffset) { NativeCall<void, FString*, float, float, float>(this, "UShooterCheatManager.SpawnActor", blueprintPath, spawnDistance, spawnYOffset, ZOffset); }

    void SpawnActorTamed(FString* blueprintPath, float spawnDistance, float spawnYOffset, float ZOffset) { NativeCall<void, FString*, float, float, float>(this, "UShooterCheatManager.SpawnActorTamed", blueprintPath, spawnDistance, spawnYOffset, ZOffset); }

    void SpawnDino(FString* blueprintPath, float spawnDistance, float spawnYOffset, float ZOffset, int DinoLevel) { NativeCall<void, FString*, float, float, float, int>(this, "UShooterCheatManager.SpawnDino", blueprintPath, spawnDistance, spawnYOffset, ZOffset, DinoLevel); }

    APrimalDinoCharacter* SpawnSetupDinoInternal(FDinoSetup* DinoSetup, FRotator* SpawnRot) { return NativeCall<APrimalDinoCharacter*, FDinoSetup*, FRotator*>(this, "UShooterCheatManager.SpawnSetupDinoInternal", DinoSetup, SpawnRot); }

    void SpawnSetupDino(FString* DinoBlueprintPath, FString* SaddleBlueprintPath, float SaddleQuality, int DinoLevel, FString* DinoStats, float SpawnDistance, float YOffset, float ZOffset) { NativeCall<void, FString*, FString*, float, int, FString*, float, float, float>(this, "UShooterCheatManager.SpawnSetupDino", DinoBlueprintPath, SaddleBlueprintPath, SaddleQuality, DinoLevel, DinoStats, SpawnDistance, YOffset, ZOffset); }

    void SpawnExactDino(FString* DinoBlueprintPath, FString* SaddleBlueprintPath, float SaddleQuality, int BaseLevel, int ExtraLevels, FString* BaseStats, FString* AddedStats, FString* DinoName, char Cloned, char Neutered, FString* TamedOn, FString* UploadedFrom, FString* ImprinterName, int ImprinterPlayerID, float ImprintQuality, FString* Colors, __int64 DinoID, __int64 Exp, float SpawnDistance, float YOffset, float ZOffset) { NativeCall<void, FString*, FString*, float, int, int, FString*, FString*, FString*, char, char, FString*, FString*, FString*, int, float, FString*, __int64, __int64, float, float, float>(this, "UShooterCheatManager.SpawnExactDino", DinoBlueprintPath, SaddleBlueprintPath, SaddleQuality, BaseLevel, ExtraLevels, BaseStats, AddedStats, DinoName, Cloned, Neutered, TamedOn, UploadedFrom, ImprinterName, ImprinterPlayerID, ImprintQuality, Colors, DinoID, Exp, SpawnDistance, YOffset, ZOffset); }

    void DumpDinoStats() { NativeCall<void>(this, "UShooterCheatManager.DumpDinoStats"); }

    AActor* DoSummon(FString* ClassName) { return NativeCall<AActor*, FString*>(this, "UShooterCheatManager.DoSummon", ClassName); }

    void Summon(FString* ClassName) { NativeCall<void, FString*>(this, "UShooterCheatManager.Summon", ClassName); }

    void SummonTamed(FString* ClassName) { NativeCall<void, FString*>(this, "UShooterCheatManager.SummonTamed", ClassName); }

    void ForceGiveBuff(FName* BuffBlueprintPath, bool bEnable) { NativeCall<void, FName*, bool>(this, "UShooterCheatManager.ForceGiveBuff", BuffBlueprintPath, bEnable); }

    void SDF(FName* DinoBlueprintPath, bool bIsTamed) { NativeCall<void, FName*, bool>(this, "UShooterCheatManager.SDF", DinoBlueprintPath, bIsTamed); }

    void SpawnActorSpread(FString* blueprintPath, float spawnDistance, float spawnYOffset, float ZOffset, int NumberActors, float SpreadAmount) { NativeCall<void, FString*, float, float, float, int, float>(this, "UShooterCheatManager.SpawnActorSpread", blueprintPath, spawnDistance, spawnYOffset, ZOffset, NumberActors, SpreadAmount); }

    void SpawnActorSpreadTamed(FString* blueprintPath, float spawnDistance, float spawnYOffset, float ZOffset, int NumberActors, float SpreadAmount) { NativeCall<void, FString*, float, float, float, int, float>(this, "UShooterCheatManager.SpawnActorSpreadTamed", blueprintPath, spawnDistance, spawnYOffset, ZOffset, NumberActors, SpreadAmount); }

    void RainDinosHelper(TArray<FString>* dinoRefs, int NumberActors, float SpreadAmount, float ZOffset) { NativeCall<void, TArray<FString>*, int, float, float>(this, "UShooterCheatManager.RainDinosHelper", dinoRefs, NumberActors, SpreadAmount, ZOffset); }

    void RainCritters(int NumberActors, float SpreadAmount, float ZOffset) { NativeCall<void, int, float, float>(this, "UShooterCheatManager.RainCritters", NumberActors, SpreadAmount, ZOffset); }

    void RainDinos(int NumberActors, float SpreadAmount, float ZOffset) { NativeCall<void, int, float, float>(this, "UShooterCheatManager.RainDinos", NumberActors, SpreadAmount, ZOffset); }

    void RainDanger(int NumberActors, float SpreadAmount, float ZOffset) { NativeCall<void, int, float, float>(this, "UShooterCheatManager.RainDanger", NumberActors, SpreadAmount, ZOffset); }

    void LeaveMeAlone() { NativeCall<void>(this, "UShooterCheatManager.LeaveMeAlone"); }

    void InfiniteStats() { NativeCall<void>(this, "UShooterCheatManager.InfiniteStats"); }

    void SetInfiniteStats(bool bInfinite) { NativeCall<void, bool>(this, "UShooterCheatManager.SetInfiniteStats", bInfinite); }

    void GiveInfiniteStatsToTarget() { NativeCall<void>(this, "UShooterCheatManager.GiveInfiniteStatsToTarget"); }

    void RefillStats() { NativeCall<void>(this, "UShooterCheatManager.RefillStats"); }

    void ToggleHud() { NativeCall<void>(this, "UShooterCheatManager.ToggleHud"); }

    void EnableCheats(FString pass) { NativeCall<void, FString>(this, "UShooterCheatManager.EnableCheats", pass); }

    void ToggleGun() { NativeCall<void>(this, "UShooterCheatManager.ToggleGun"); }

    void ToggleDamageNumbers() { NativeCall<void>(this, "UShooterCheatManager.ToggleDamageNumbers"); }

    void ToggleDamageLogging() { NativeCall<void>(this, "UShooterCheatManager.ToggleDamageLogging"); }

    void SetGodMode(bool bEnable) { NativeCall<void, bool>(this, "UShooterCheatManager.SetGodMode", bEnable); }

    void BanPlayer(FString PlayerSteamName) { NativeCall<void, FString>(this, "UShooterCheatManager.BanPlayer", PlayerSteamName); }

    void UnbanPlayer(FString PlayerSteamName) { NativeCall<void, FString>(this, "UShooterCheatManager.UnbanPlayer", PlayerSteamName); }

    void EnableSpectator() { NativeCall<void>(this, "UShooterCheatManager.EnableSpectator"); }

    void DisableSpectator() { NativeCall<void>(this, "UShooterCheatManager.DisableSpectator"); }

    void KickPlayer(FString PlayerSteamName) { NativeCall<void, FString>(this, "UShooterCheatManager.KickPlayer", PlayerSteamName); }

    void Suicide() { NativeCall<void>(this, "UShooterCheatManager.Suicide"); }

    void ForceTame() { NativeCall<void>(this, "UShooterCheatManager.ForceTame"); }

    void ForceTameAOE(float Radius) { NativeCall<void, float>(this, "UShooterCheatManager.ForceTameAOE", Radius); }

    void SetImprintQuality(float ImprintQuality) { NativeCall<void, float>(this, "UShooterCheatManager.SetImprintQuality", ImprintQuality); }

    void SetTamingEffectivenessModifier(float TamingEffectiveness) { NativeCall<void, float>(this, "UShooterCheatManager.SetTamingEffectivenessModifier", TamingEffectiveness); }

    void StartNearestHorde(FName HordeType, int DifficultyLevel) { NativeCall<void, FName, int>(this, "UShooterCheatManager.StartNearestHorde", HordeType, DifficultyLevel); }

    void ListActiveHordeEvents() { NativeCall<void>(this, "UShooterCheatManager.ListActiveHordeEvents"); }

    void TeleportToActiveHorde(int EventIndex) { NativeCall<void, int>(this, "UShooterCheatManager.TeleportToActiveHorde", EventIndex); }

    void SetImprintedPlayer(FString NewImprinterName, int NewImprinterPlayerDataID) { NativeCall<void, FString, int>(this, "UShooterCheatManager.SetImprintedPlayer", NewImprinterName, NewImprinterPlayerDataID); }

    void TransferImprints(int oldPlayerId, int newPlayerId, FString NewImprinterName) { NativeCall<void, int, int, FString>(this, "UShooterCheatManager.TransferImprints", oldPlayerId, newPlayerId, NewImprinterName); }

    void DoTame() { NativeCall<void>(this, "UShooterCheatManager.DoTame"); }

    void GiveToMe() { NativeCall<void>(this, "UShooterCheatManager.GiveToMe"); }

    void GiveToMeAOE(float Radius) { NativeCall<void, float>(this, "UShooterCheatManager.GiveToMeAOE", Radius); }

    void GiveAllStructure() { NativeCall<void>(this, "UShooterCheatManager.GiveAllStructure"); }

    void SetTargetPlayerBodyVal(int BodyValIndex, float BodyVal) { NativeCall<void, int, float>(this, "UShooterCheatManager.SetTargetPlayerBodyVal", BodyValIndex, BodyVal); }

    void SetTargetPlayerColorVal(int ColorValIndex, float ColorVal) { NativeCall<void, int, float>(this, "UShooterCheatManager.SetTargetPlayerColorVal", ColorValIndex, ColorVal); }

    void SetBabyAge(float AgeValue) { NativeCall<void, float>(this, "UShooterCheatManager.SetBabyAge", AgeValue); }

    void ListPlayers() { NativeCall<void>(this, "UShooterCheatManager.ListPlayers"); }

    void GetChat() { NativeCall<void>(this, "UShooterCheatManager.GetChat"); }

    void GetGameLog() { NativeCall<void>(this, "UShooterCheatManager.GetGameLog"); }

    void EnemyInVisible(bool Invisible) { NativeCall<void, bool>(this, "UShooterCheatManager.EnemyInVisible", Invisible); }

    void ShowTutorial(int TutorialIndex, bool bForceDisplay) { NativeCall<void, int, bool>(this, "UShooterCheatManager.ShowTutorial", TutorialIndex, bForceDisplay); }

    void HideTutorial(int TutorialInde) { NativeCall<void, int>(this, "UShooterCheatManager.HideTutorial", TutorialInde); }

    void ClearTutorials() { NativeCall<void>(this, "UShooterCheatManager.ClearTutorials"); }

    void TestSteamRefreshItems() { NativeCall<void>(this, "UShooterCheatManager.TestSteamRefreshItems"); }

    void AddItemToAllClustersInventory(FString UserId, int MasterIndexNum) { NativeCall<void, FString, int>(this, "UShooterCheatManager.AddItemToAllClustersInventory", UserId, MasterIndexNum); }

    void GiveItemNum(int masterIndexNum, int quantityOverride, float qualityOverride, bool bForceBlueprint) { NativeCall<void, int, int, float, bool>(this, "UShooterCheatManager.GiveItemNum", masterIndexNum, quantityOverride, qualityOverride, bForceBlueprint); }

    void GiveItem(FString* blueprintPath, int quantityOverride, float qualityOverride, bool bForceBlueprint) { NativeCall<void, FString*, int, float, bool>(this, "UShooterCheatManager.GiveItem", blueprintPath, quantityOverride, qualityOverride, bForceBlueprint); }

    static void GiveAllItemsInSet(AShooterPlayerController* Controller, TArray<FItemCount>* Items) { NativeCall<void, AShooterPlayerController*, TArray<FItemCount>*>(nullptr, "UShooterCheatManager.GiveAllItemsInSet", Controller, Items); }

    static float QualityNameToFloat(FName QualityName) { return NativeCall<float, FName>(nullptr, "UShooterCheatManager.QualityNameToFloat", QualityName); }

    void GiveArmorSet(FName Tier, FName QualityName) { NativeCall<void, FName, FName>(this, "UShooterCheatManager.GiveArmorSet", Tier, QualityName); }

    void GiveWeaponSet(FName Tier, FName QualityName) { NativeCall<void, FName, FName>(this, "UShooterCheatManager.GiveWeaponSet", Tier, QualityName); }

    void GiveItemSet(FName Tier) { NativeCall<void, FName>(this, "UShooterCheatManager.GiveItemSet", Tier); }

    void GMComp(int level) { NativeCall<void, int>(this, "UShooterCheatManager.GMComp", level); }

    void GiveDinoSet(FName Tier, int NumDinos) { NativeCall<void, FName, int>(this, "UShooterCheatManager.GiveDinoSet", Tier, NumDinos); }

    void GiveDinoSet() { NativeCall<void>(this, "UShooterCheatManager.GiveDinoSet"); }

    void AddEquipmentDurability(const float durability) { NativeCall<void, const float>(this, "UShooterCheatManager.AddEquipmentDurability", durability); }

    void GFI(FName* blueprintPath, int quantityOverride, float qualityOverride, bool bForceBlueprint) { NativeCall<void, FName*, int, float, bool>(this, "UShooterCheatManager.GFI", blueprintPath, quantityOverride, qualityOverride, bForceBlueprint); }

    void GiveItemToPlayer(int playerID, FString* blueprintPath, int quantityOverride, float qualityOverride, bool bForceBlueprint) { NativeCall<void, int, FString*, int, float, bool>(this, "UShooterCheatManager.GiveItemToPlayer", playerID, blueprintPath, quantityOverride, qualityOverride, bForceBlueprint); }

    void GiveItemNumToPlayer(int playerID, int masterIndexNum, int quantityOverride, float qualityOverride, bool bForceBlueprint) { NativeCall<void, int, int, int, float, bool>(this, "UShooterCheatManager.GiveItemNumToPlayer", playerID, masterIndexNum, quantityOverride, qualityOverride, bForceBlueprint); }

    void ClearPlayerInventory(int playerID, bool bClearInventory, bool bClearSlotItems, bool bClearEquippedItems) { NativeCall<void, int, bool, bool, bool>(this, "UShooterCheatManager.ClearPlayerInventory", playerID, bClearInventory, bClearSlotItems, bClearEquippedItems); }

    void DoTestingThing() { NativeCall<void>(this, "UShooterCheatManager.DoTestingThing"); }

    void DoHang() { NativeCall<void>(this, "UShooterCheatManager.DoHang"); }

    void SetMessageOfTheDay(FString* Message) { NativeCall<void, FString*>(this, "UShooterCheatManager.SetMessageOfTheDay", Message); }

    void ShowMessageOfTheDay() { NativeCall<void>(this, "UShooterCheatManager.ShowMessageOfTheDay"); }

    void ReportSpawnManagers() { NativeCall<void>(this, "UShooterCheatManager.ReportSpawnManagers"); }

    void HibernationReport(FString* ClassName) { NativeCall<void, FString*>(this, "UShooterCheatManager.HibernationReport", ClassName); }

    void HiWarp(FString* ClassName, int Index) { NativeCall<void, FString*, int>(this, "UShooterCheatManager.HiWarp", ClassName, Index); }

    void ReportLeastSpawnManagers() { NativeCall<void>(this, "UShooterCheatManager.ReportLeastSpawnManagers"); }

    void DestroyAllEnemies() { NativeCall<void>(this, "UShooterCheatManager.DestroyAllEnemies"); }

    void DestroyWildDinos() { NativeCall<void>(this, "UShooterCheatManager.DestroyWildDinos"); }

    void DestroyStructures() { NativeCall<void>(this, "UShooterCheatManager.DestroyStructures"); }

    void SetPlayerPos(float X, float Y, float Z) { NativeCall<void, float, float, float>(this, "UShooterCheatManager.SetPlayerPos", X, Y, Z); }

    void PrintActorLocation(FString* ActorName) { NativeCall<void, FString*>(this, "UShooterCheatManager.PrintActorLocation", ActorName); }

    void TeleportToActorLocation(FString* ActorName) { NativeCall<void, FString*>(this, "UShooterCheatManager.TeleportToActorLocation", ActorName); }

    void SPI(float X, float Y, float Z, float Yaw, float Pitch) { NativeCall<void, float, float, float, float, float>(this, "UShooterCheatManager.SPI", X, Y, Z, Yaw, Pitch); }

    void TP(FString LocationName) { NativeCall<void, FString>(this, "UShooterCheatManager.TP", LocationName); }

    void TPCoords(float lat, float lon, float z) { NativeCall<void, float, float, float>(this, "UShooterCheatManager.TPCoords", lat, lon, z); }

    void ToggleLocation() { NativeCall<void>(this, "UShooterCheatManager.ToggleLocation"); }

    void SaveWorldDisableTransfer() { NativeCall<void>(this, "UShooterCheatManager.SaveWorldDisableTransfer"); }

    void SetTimeOfDay(FString* timeString) { NativeCall<void, FString*>(this, "UShooterCheatManager.SetTimeOfDay", timeString); }

    void WhatIsMyTarget() { NativeCall<void>(this, "UShooterCheatManager.WhatIsMyTarget"); }

    void IsUndermesh(const float debugDrawSeconds) { NativeCall<void, const float>(this, "UShooterCheatManager.IsUndermesh", debugDrawSeconds); }

    void SetDebugMeleeAttacks(bool bDebugMelee, const float drawDuration) { NativeCall<void, bool, const float>(this, "UShooterCheatManager.SetDebugMeleeAttacks", bDebugMelee, drawDuration); }

    void MoveTargetTo(float x, float y, float z) { NativeCall<void, float, float, float>(this, "UShooterCheatManager.MoveTargetTo", x, y, z); }

    void ServerChatTo(FString* SteamID, FString* MessageText) { NativeCall<void, FString*, FString*>(this, "UShooterCheatManager.ServerChatTo", SteamID, MessageText); }

    void ServerChatToPlayer(FString* PlayerName, FString* MessageText) { NativeCall<void, FString*, FString*>(this, "UShooterCheatManager.ServerChatToPlayer", PlayerName, MessageText); }

    void ServerChat(FString* MessageText) { NativeCall<void, FString*>(this, "UShooterCheatManager.ServerChat", MessageText); }

    void SetChatLogMaxAgeInDays(int NumDays) { NativeCall<void, int>(this, "UShooterCheatManager.SetChatLogMaxAgeInDays", NumDays); }

    void ForceUpdateDynamicConfig() { NativeCall<void>(this, "UShooterCheatManager.ForceUpdateDynamicConfig"); }

    void DumpAssetProperties(FString* Asset) { NativeCall<void, FString*>(this, "UShooterCheatManager.DumpAssetProperties", Asset); }

    void ResetLiveTuningOverloads() { NativeCall<void>(this, "UShooterCheatManager.ResetLiveTuningOverloads"); }

    AShooterPlayerController* FindPlayerControllerFromPlayerID(__int64 PlayerID) { return NativeCall<AShooterPlayerController*, __int64>(this, "UShooterCheatManager.FindPlayerControllerFromPlayerID", PlayerID); }

    void GameCommand(FString* TheCommand) { NativeCall<void, FString*>(this, "UShooterCheatManager.GameCommand", TheCommand); }

    void ScriptCommand(FString* commandString) { NativeCall<void, FString*>(this, "UShooterCheatManager.ScriptCommand", commandString); }

    void PlayerCommand(FString* TheCommand) { NativeCall<void, FString*>(this, "UShooterCheatManager.PlayerCommand", TheCommand); }

    void MakeTribeAdmin() { NativeCall<void>(this, "UShooterCheatManager.MakeTribeAdmin"); }

    void RemoveTribeAdmin() { NativeCall<void>(this, "UShooterCheatManager.RemoveTribeAdmin"); }

    void MakeTribeFounder() { NativeCall<void>(this, "UShooterCheatManager.MakeTribeFounder"); }

    void GiveExplorerNote(int NoteIndex) { NativeCall<void, int>(this, "UShooterCheatManager.GiveExplorerNote", NoteIndex); }

    void GiveAllExplorerNotes() { NativeCall<void>(this, "UShooterCheatManager.GiveAllExplorerNotes"); }

    void VisualizeClass(FString* ClassIn, int MaxTotal) { NativeCall<void, FString*, int>(this, "UShooterCheatManager.VisualizeClass", ClassIn, MaxTotal); }

    void UnlockEngram(FString* ItemClassName) { NativeCall<void, FString*>(this, "UShooterCheatManager.UnlockEngram", ItemClassName); }

    void SetHeadHairPercent(float thePercent) { NativeCall<void, float>(this, "UShooterCheatManager.SetHeadHairPercent", thePercent); }

    void SetFacialHairPercent(float thePercent) { NativeCall<void, float>(this, "UShooterCheatManager.SetFacialHairPercent", thePercent); }

    void SetHeadHairstyle(int hairStyleIndex) { NativeCall<void, int>(this, "UShooterCheatManager.SetHeadHairstyle", hairStyleIndex); }

    void SetFacialHairstyle(int hairStyleIndex) { NativeCall<void, int>(this, "UShooterCheatManager.SetFacialHairstyle", hairStyleIndex); }

    void PrintMessageOut(FString* Msg) { NativeCall<void, FString*>(this, "UShooterCheatManager.PrintMessageOut", Msg); }

    void GetTribeIdPlayerList(int TribeID) { NativeCall<void, int>(this, "UShooterCheatManager.GetTribeIdPlayerList", TribeID); }

    void GetSteamIDForPlayerID(int PlayerID) { NativeCall<void, int>(this, "UShooterCheatManager.GetSteamIDForPlayerID", PlayerID); }

    void GetPlayerIDForSteamID(int SteamID) { NativeCall<void, int>(this, "UShooterCheatManager.GetPlayerIDForSteamID", SteamID); }

    void SetShowAllPlayers(bool bEnable) { NativeCall<void, bool>(this, "UShooterCheatManager.SetShowAllPlayers", bEnable); }

    void SAP() { NativeCall<void>(this, "UShooterCheatManager.SAP"); }

    void TribeStructureAudit(int TribeTeamID) { NativeCall<void, int>(this, "UShooterCheatManager.TribeStructureAudit", TribeTeamID); }

    void TribeDinoAudit(int TribeTeamID) { NativeCall<void, int>(this, "UShooterCheatManager.TribeDinoAudit", TribeTeamID); }

    void psc(FString* command) { NativeCall<void, FString*>(this, "UShooterCheatManager.psc", command); }

    void DetachChar() { NativeCall<void>(this, "UShooterCheatManager.DetachChar"); }

    void VerifyTransferInventory() { NativeCall<void>(this, "UShooterCheatManager.VerifyTransferInventory"); }

    void HatchEgg() { NativeCall<void>(this, "UShooterCheatManager.HatchEgg"); }

    void DefeatBoss(int playerID, FName bossName, char difficulty) { NativeCall<void, int, FName, char>(this, "UShooterCheatManager.DefeatBoss", playerID, bossName, difficulty); }

    void LvlUp(__int64 PlayerID, __int16 Level) { NativeCall<void, __int64, __int16>(this, "UShooterCheatManager.LvlUp", PlayerID, Level); }

    void LessThan(int TribeTeamID, int Connections, bool includeContainers) { NativeCall<void, int, int, bool>(this, "UShooterCheatManager.LessThan", TribeTeamID, Connections, includeContainers); }

    void SetInstantHarvest(bool bEnable) { NativeCall<void, bool>(this, "UShooterCheatManager.SetInstantHarvest", bEnable); }

    void DestroyFoliage(float Radius) { NativeCall<void, float>(this, "UShooterCheatManager.DestroyFoliage", Radius); }

    void RegrowFoliage(float Radius) { NativeCall<void, float>(this, "UShooterCheatManager.RegrowFoliage", Radius); }

    void ToggleLowGravSpin() { NativeCall<void>(this, "UShooterCheatManager.ToggleLowGravSpin"); }

    void ForceCheckInMesh() { NativeCall<void>(this, "UShooterCheatManager.ForceCheckInMesh"); }

    void ForceEnableMeshCheckingOnMe(bool bEnableChecking) { NativeCall<void, bool>(this, "UShooterCheatManager.ForceEnableMeshCheckingOnMe", bEnableChecking); }

    void SetPlayerLevel(__int64 PlayerID, __int16 Level) { NativeCall<void, __int64, __int16>(this, "UShooterCheatManager.SetPlayerLevel", PlayerID, Level); }

    void SendDataDogMetric(FString msg) { NativeCall<void, FString>(this, "UShooterCheatManager.SendDataDogMetric", msg); }

    void MaxAscend(int playerID) { NativeCall<void, int>(this, "UShooterCheatManager.MaxAscend", playerID); }

    void DefeatAllBosses(int playerID) { NativeCall<void, int>(this, "UShooterCheatManager.DefeatAllBosses", playerID); }

    void ReassertColorization() { NativeCall<void>(this, "UShooterCheatManager.ReassertColorization"); }

    void AddHexagons(float HowMuch) { NativeCall<void, float>(this, "UShooterCheatManager.AddHexagons", HowMuch); }

    void DebugAllowVRMissionTeleport() { NativeCall<void>(this, "UShooterCheatManager.DebugAllowVRMissionTeleport"); }

    void ToggleClawStepping() { NativeCall<void>(this, "UShooterCheatManager.ToggleClawStepping"); }

    void God() { NativeCall<void>(this, "UShooterCheatManager.God"); }

    void DupeLastItem() { NativeCall<void>(this, "UShooterCheatManager.DupeLastItem"); }

    void ForceCompleteActiveMission(FString* MissionStateSimValues) { NativeCall<void, FString*>(this, "UShooterCheatManager.ForceCompleteActiveMission", MissionStateSimValues); }

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

    static void StaticRegisterNativesUShooterCheatManager() { NativeCall<void>(nullptr, "UShooterCheatManager.StaticRegisterNativesUShooterCheatManager"); }

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

};


struct UPlayer : UObject

{

    APlayerController * PlayerControllerField() { return *GetNativePointerField<APlayerController**>(this, "UPlayer.PlayerController"); }

    int& CurrentNetSpeedField() { return *GetNativePointerField<int*>(this, "UPlayer.CurrentNetSpeed"); }

    int& ConfiguredInternetSpeedField() { return *GetNativePointerField<int*>(this, "UPlayer.ConfiguredInternetSpeed"); }

    int& ConfiguredLanSpeedField() { return *GetNativePointerField<int*>(this, "UPlayer.ConfiguredLanSpeed"); }

    unsigned __int64& TransferringPlayerDataIdField() { return *GetNativePointerField<unsigned __int64*>(this, "UPlayer.TransferringPlayerDataId"); }


    // Functions


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

};


struct UNetConnection : UPlayer

{

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

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

};


struct APlayerState : AInfo

{

    float& ScoreField() { return *GetNativePointerField<float*>(this, "APlayerState.Score"); }

    char& PingField() { return *GetNativePointerField<char*>(this, "APlayerState.Ping"); }

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

    FString& OldNameField() { return *GetNativePointerField<FString*>(this, "APlayerState.OldName"); }

    int& PlayerIdField() { return *GetNativePointerField<int*>(this, "APlayerState.PlayerId"); }

    int& StartTimeField() { return *GetNativePointerField<int*>(this, "APlayerState.StartTime"); }

    float& ExactPingField() { return *GetNativePointerField<float*>(this, "APlayerState.ExactPing"); }

    FString& SavedNetworkAddressField() { return *GetNativePointerField<FString*>(this, "APlayerState.SavedNetworkAddress"); }

    FUniqueNetIdRepl& UniqueIdField() { return *GetNativePointerField<FUniqueNetIdRepl*>(this, "APlayerState.UniqueId"); }

    FName& SessionNameField() { return *GetNativePointerField<FName*>(this, "APlayerState.SessionName"); }

    char& CurPingBucketField() { return *GetNativePointerField<char*>(this, "APlayerState.CurPingBucket"); }

    float& CurPingBucketTimestampField() { return *GetNativePointerField<float*>(this, "APlayerState.CurPingBucketTimestamp"); }


    // Bit fields


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

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

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

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

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

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


    // Functions


    UField* StaticClass() { return NativeCall<UField*>(this, "APlayerState.StaticClass"); }

    void UpdatePing(float InPing) { NativeCall<void, float>(this, "APlayerState.UpdatePing", InPing); }

    void RecalculateAvgPing() { NativeCall<void>(this, "APlayerState.RecalculateAvgPing"); }

    void OverrideWith(APlayerState* PlayerState) { NativeCall<void, APlayerState*>(this, "APlayerState.OverrideWith", PlayerState); }

    void CopyProperties(APlayerState* PlayerState) { NativeCall<void, APlayerState*>(this, "APlayerState.CopyProperties", PlayerState); }

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

    void ClientInitialize(AController* C) { NativeCall<void, AController*>(this, "APlayerState.ClientInitialize", C); }

    void OnRep_PlayerName() { NativeCall<void>(this, "APlayerState.OnRep_PlayerName"); }

    void OnRep_bIsInactive() { NativeCall<void>(this, "APlayerState.OnRep_bIsInactive"); }

    bool ShouldBroadCastWelcomeMessage(bool bExiting) { return NativeCall<bool, bool>(this, "APlayerState.ShouldBroadCastWelcomeMessage", bExiting); }

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

    void Reset() { NativeCall<void>(this, "APlayerState.Reset"); }

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

    void SetPlayerName(FString* S) { NativeCall<void, FString*>(this, "APlayerState.SetPlayerName", S); }

    void OnRep_UniqueId() { NativeCall<void>(this, "APlayerState.OnRep_UniqueId"); }

    void SetUniqueId(TSharedPtr<FUniqueNetId, 0>* InUniqueId) { NativeCall<void, TSharedPtr<FUniqueNetId, 0>*>(this, "APlayerState.SetUniqueId", InUniqueId); }

    void RegisterPlayerWithSession(bool bWasFromInvite) { NativeCall<void, bool>(this, "APlayerState.RegisterPlayerWithSession", bWasFromInvite); }

    APlayerState* Duplicate() { return NativeCall<APlayerState*>(this, "APlayerState.Duplicate"); }

    void SeamlessTravelTo(APlayerState* NewPlayerState) { NativeCall<void, APlayerState*>(this, "APlayerState.SeamlessTravelTo", NewPlayerState); }

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

    static void StaticRegisterNativesAPlayerState() { NativeCall<void>(nullptr, "APlayerState.StaticRegisterNativesAPlayerState"); }

};


struct AShooterPlayerState : APlayerState

{

    UPrimalPlayerData * MyPlayerDataField() { return *GetNativePointerField<UPrimalPlayerData**>(this, "AShooterPlayerState.MyPlayerData"); }

    FPrimalPlayerDataStruct * MyPlayerDataStructField() { return GetNativePointerField<FPrimalPlayerDataStruct*>(this, "AShooterPlayerState.MyPlayerDataStruct"); }

    FieldArray<TSubclassOf<UPrimalItem>, 10> DefaultItemSlotClassesField() { return {this, "AShooterPlayerState.DefaultItemSlotClasses"}; }

    FieldArray<char, 10> DefaultItemSlotEngramsField() { return {this, "AShooterPlayerState.DefaultItemSlotEngrams"}; }

    FTribeData * MyTribeDataField() { return GetNativePointerField<FTribeData*>(this, "AShooterPlayerState.MyTribeData"); }

    FTribeData * LastTribeInviteDataField() { return GetNativePointerField<FTribeData*>(this, "AShooterPlayerState.LastTribeInviteData"); }

    TArray<FSpawnPointInfo> & CachedSpawnPointInfosField() { return *GetNativePointerField<TArray<FSpawnPointInfo>*>(this, "AShooterPlayerState.CachedSpawnPointInfos"); }

    int& TotalEngramPointsField() { return *GetNativePointerField<int*>(this, "AShooterPlayerState.TotalEngramPoints"); }

    int& FreeEngramPointsField() { return *GetNativePointerField<int*>(this, "AShooterPlayerState.FreeEngramPoints"); }

    TArray<TSubclassOf<UPrimalItem>> & EngramItemBlueprintsField() { return *GetNativePointerField<TArray<TSubclassOf<UPrimalItem>>*>(this, "AShooterPlayerState.EngramItemBlueprints"); }

    TSet<TSubclassOf<UPrimalItem>,DefaultKeyFuncs<TSubclassOf<UPrimalItem>,0>,FDefaultSetAllocator> & ServerEngramItemBlueprintsSetField() { return *GetNativePointerField<TSet<TSubclassOf<UPrimalItem>,DefaultKeyFuncs<TSubclassOf<UPrimalItem>,0>,FDefaultSetAllocator>*>(this, "AShooterPlayerState.ServerEngramItemBlueprintsSet"); }

    long double& NextAllowedRespawnTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerState.NextAllowedRespawnTime"); }

    long double& LastFlexPipeRefreshConnectionsNetworkTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerState.LastFlexPipeRefreshConnectionsNetworkTime"); }

    float& AllowedRespawnIntervalField() { return *GetNativePointerField<float*>(this, "AShooterPlayerState.AllowedRespawnInterval"); }

    long double& LastTimeDiedToEnemyTeamField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerState.LastTimeDiedToEnemyTeam"); }

    int& CurrentlySelectedDinoOrderGroupField() { return *GetNativePointerField<int*>(this, "AShooterPlayerState.CurrentlySelectedDinoOrderGroup"); }

    FieldArray<FDinoOrderGroup, 10> DinoOrderGroupsField() { return {this, "AShooterPlayerState.DinoOrderGroups"}; }

    long double& GenesisAbilityErrorLastTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerState.GenesisAbilityErrorLastTime"); }

    long double& LastTribeRequestTimeField() { return *GetNativePointerField<long double*>(this, "AShooterPlayerState.LastTribeRequestTime"); }


    // Bit fields


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


    // Functions


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

    void Reset() { NativeCall<void>(this, "AShooterPlayerState.Reset"); }

    void UnregisterPlayerWithSession() { NativeCall<void>(this, "AShooterPlayerState.UnregisterPlayerWithSession"); }

    void ClientInitialize(AController * InController) { NativeCall<void, AController*>(this, "AShooterPlayerState.ClientInitialize", InController); }

    void SetQuitter(bool bInQuitter) { NativeCall<void, bool>(this, "AShooterPlayerState.SetQuitter", bInQuitter); }

    void CopyProperties(APlayerState * PlayerState) { NativeCall<void, APlayerState*>(this, "AShooterPlayerState.CopyProperties", PlayerState); }

    void ServerGetAllPlayerNamesAndLocations_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerGetAllPlayerNamesAndLocations_Implementation"); }

    void ServerGetAlivePlayerConnectedData_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerGetAlivePlayerConnectedData_Implementation"); }

    void ServerGetPlayerConnectedData_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerGetPlayerConnectedData_Implementation"); }

    void ServerGetServerOptions_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerGetServerOptions_Implementation"); }

    void ServerGetPlayerBannedData_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerGetPlayerBannedData_Implementation"); }

    void ServerGetPlayerWhiteListedData_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerGetPlayerWhiteListedData_Implementation"); }

    void ClientGetAlivePlayerConnectedData_Implementation(TArray<FAlivePlayerDataInfo> * list) { NativeCall<void, TArray<FAlivePlayerDataInfo>*>(this, "AShooterPlayerState.ClientGetAlivePlayerConnectedData_Implementation", list); }

    void ClientGetPlayerConnectedData_Implementation(TArray<FAdminPlayerDataInfo> * list) { NativeCall<void, TArray<FAdminPlayerDataInfo>*>(this, "AShooterPlayerState.ClientGetPlayerConnectedData_Implementation", list); }

    void ClientGetServerOptions_Implementation(FServerOptions info) { NativeCall<void, FServerOptions>(this, "AShooterPlayerState.ClientGetServerOptions_Implementation", info); }

    void ClientGetPlayerBannedData_Implementation(TArray<FAdminPlayerDataInfo> * list) { NativeCall<void, TArray<FAdminPlayerDataInfo>*>(this, "AShooterPlayerState.ClientGetPlayerBannedData_Implementation", list); }

    void ClientGetPlayerWhiteListedData_Implementation(TArray<FAdminPlayerDataInfo> * list) { NativeCall<void, TArray<FAdminPlayerDataInfo>*>(this, "AShooterPlayerState.ClientGetPlayerWhiteListedData_Implementation", list); }

    void BroadcastDeath_Implementation(AShooterPlayerState * KillerPlayerState, UDamageType * KillerDamageType, AShooterPlayerState * KilledPlayerState) { NativeCall<void, AShooterPlayerState*, UDamageType*, AShooterPlayerState*>(this, "AShooterPlayerState.BroadcastDeath_Implementation", KillerPlayerState, KillerDamageType, KilledPlayerState); }

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

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

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

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

    void PromoteToTribeAdmin(APlayerController * PromoterPC) { NativeCall<void, APlayerController*>(this, "AShooterPlayerState.PromoteToTribeAdmin", PromoterPC); }

    bool AddToTribe(FTribeData * MyNewTribe, bool bMergeTribe, bool bForce, bool bIsFromInvite, APlayerController * InviterPC) { return NativeCall<bool, FTribeData*, bool, bool, bool, APlayerController*>(this, "AShooterPlayerState.AddToTribe", MyNewTribe, bMergeTribe, bForce, bIsFromInvite, InviterPC); }

    void UpdateTribeData(FTribeData * TribeData) { NativeCall<void, FTribeData*>(this, "AShooterPlayerState.UpdateTribeData", TribeData); }

    void ClearTribe(bool bDontRemoveFromTribe, bool bForce, APlayerController * ForPC) { NativeCall<void, bool, bool, APlayerController*>(this, "AShooterPlayerState.ClearTribe", bDontRemoveFromTribe, bForce, ForPC); }

    bool IsInTribe() { return NativeCall<bool>(this, "AShooterPlayerState.IsInTribe"); }

    void TransferTribalObjects(FTribeData * TribeData, bool bTransferToTribe, bool bDontIncludePlayers) { NativeCall<void, FTribeData*, bool, bool>(this, "AShooterPlayerState.TransferTribalObjects", TribeData, bTransferToTribe, bDontIncludePlayers); }

    bool IsTribeOwner(unsigned int CheckPlayerDataID) { return NativeCall<bool, unsigned int>(this, "AShooterPlayerState.IsTribeOwner", CheckPlayerDataID); }

    bool IsTribeFounder() { return NativeCall<bool>(this, "AShooterPlayerState.IsTribeFounder"); }

    bool IsTribeAdmin() { return NativeCall<bool>(this, "AShooterPlayerState.IsTribeAdmin"); }

    void ServerRequestDinoOrderGroups_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerRequestDinoOrderGroups_Implementation"); }

    void ClientRefreshDinoOrderGroup_Implementation(int groupIndex, FDinoOrderGroup groupData, int UseCurrentlySelectedGroup) { NativeCall<void, int, FDinoOrderGroup, int>(this, "AShooterPlayerState.ClientRefreshDinoOrderGroup_Implementation", groupIndex, groupData, UseCurrentlySelectedGroup); }

    bool AllowDinoOrderByGroup(APrimalDinoCharacter * orderDino) { return NativeCall<bool, APrimalDinoCharacter*>(this, "AShooterPlayerState.AllowDinoOrderByGroup", orderDino); }

    void LocalSetSelectedDinoOrderGroup(int newGroup, bool bDontToggle) { NativeCall<void, int, bool>(this, "AShooterPlayerState.LocalSetSelectedDinoOrderGroup", newGroup, bDontToggle); }

    void ServerDinoOrderGroup_AddOrRemoveDinoClass_Implementation(int groupIndex, TSubclassOf<APrimalDinoCharacter> DinoClass, bool bAdd) { NativeCall<void, int, TSubclassOf<APrimalDinoCharacter>, bool>(this, "AShooterPlayerState.ServerDinoOrderGroup_AddOrRemoveDinoClass_Implementation", groupIndex, DinoClass, bAdd); }

    void ServerSetDinoGroupName_Implementation(int groupIndex, FString * GroupName) { NativeCall<void, int, FString*>(this, "AShooterPlayerState.ServerSetDinoGroupName_Implementation", groupIndex, GroupName); }

    FString * GetDinoOrderGroupName(FString * result, int groupIndex) { return NativeCall<FString*, FString*, int>(this, "AShooterPlayerState.GetDinoOrderGroupName", result, groupIndex); }

    bool IsDinoInOrderGroup(int groupIndex, APrimalDinoCharacter * dinoChar) { return NativeCall<bool, int, APrimalDinoCharacter*>(this, "AShooterPlayerState.IsDinoInOrderGroup", groupIndex, dinoChar); }

    bool IsDinoClassInOrderGroup(int groupIndex, TSubclassOf<APrimalDinoCharacter> dinoClass) { return NativeCall<bool, int, TSubclassOf<APrimalDinoCharacter>>(this, "AShooterPlayerState.IsDinoClassInOrderGroup", groupIndex, dinoClass); }

    void ServerDinoOrderGroup_AddOrRemoveDinoCharacter_Implementation(int groupIndex, APrimalDinoCharacter * DinoCharacter, bool bAdd) { NativeCall<void, int, APrimalDinoCharacter*, bool>(this, "AShooterPlayerState.ServerDinoOrderGroup_AddOrRemoveDinoCharacter_Implementation", groupIndex, DinoCharacter, bAdd); }

    void ServerDinoOrderGroup_Clear_Implementation(int groupIndex, bool bClearClasses, bool bClearChars) { NativeCall<void, int, bool, bool>(this, "AShooterPlayerState.ServerDinoOrderGroup_Clear_Implementation", groupIndex, bClearClasses, bClearChars); }

    void ServerDinoOrderGroup_RemoveEntryByIndex_Implementation(int groupIndex, bool bIsClass, int entryIndex) { NativeCall<void, int, bool, int>(this, "AShooterPlayerState.ServerDinoOrderGroup_RemoveEntryByIndex_Implementation", groupIndex, bIsClass, entryIndex); }

    void ServerSetSelectedDinoOrderGroup_Implementation(int newGroup) { NativeCall<void, int>(this, "AShooterPlayerState.ServerSetSelectedDinoOrderGroup_Implementation", newGroup); }

    void ServerRequestRenameTribe_Implementation(FString * TribeName) { NativeCall<void, FString*>(this, "AShooterPlayerState.ServerRequestRenameTribe_Implementation", TribeName); }

    void ServerRequestSetTribeGovernment_Implementation(FTribeGovernment TribeGovernment) { NativeCall<void, FTribeGovernment>(this, "AShooterPlayerState.ServerRequestSetTribeGovernment_Implementation", TribeGovernment); }

    void ServerRequestCreateNewTribe_Implementation(FString * TribeName, FTribeGovernment TribeGovernment) { NativeCall<void, FString*, FTribeGovernment>(this, "AShooterPlayerState.ServerRequestCreateNewTribe_Implementation", TribeName, TribeGovernment); }

    void ServerRequestLeaveTribe_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ServerRequestLeaveTribe_Implementation"); }

    void ServerRequestRemovePlayerIndexFromMyTribe_Implementation(int PlayerIndexInTribe) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRequestRemovePlayerIndexFromMyTribe_Implementation", PlayerIndexInTribe); }

    void ServerRequestPromotePlayerInMyTribe_Implementation(int PlayerIndexInTribe) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRequestPromotePlayerInMyTribe_Implementation", PlayerIndexInTribe); }

    void ServerRequestDemotePlayerInMyTribe_Implementation(int PlayerIndexInTribe) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRequestDemotePlayerInMyTribe_Implementation", PlayerIndexInTribe); }

    void InvitedRankGroupPlayerIntoTribe(AShooterPlayerState * OtherPlayer) { NativeCall<void, AShooterPlayerState*>(this, "AShooterPlayerState.InvitedRankGroupPlayerIntoTribe", OtherPlayer); }

    void ServerRequestSetTribeMemberGroupRank_Implementation(int PlayerIndexInTribe, int RankGroupIndex) { NativeCall<void, int, int>(this, "AShooterPlayerState.ServerRequestSetTribeMemberGroupRank_Implementation", PlayerIndexInTribe, RankGroupIndex); }

    void ServerTribeRequestAddRankGroup_Implementation(FString * GroupName) { NativeCall<void, FString*>(this, "AShooterPlayerState.ServerTribeRequestAddRankGroup_Implementation", GroupName); }

    void ServerTribeRequestRemoveRankGroup_Implementation(int RankGroupIndex) { NativeCall<void, int>(this, "AShooterPlayerState.ServerTribeRequestRemoveRankGroup_Implementation", RankGroupIndex); }

    void ServerTribeRequestApplyRankGroupSettings_Implementation(int RankGroupIndex, FTribeRankGroup newGroupSettings) { NativeCall<void, int, FTribeRankGroup>(this, "AShooterPlayerState.ServerTribeRequestApplyRankGroupSettings_Implementation", RankGroupIndex, newGroupSettings); }

    void ServerRequestTransferOwnershipInMyTribe_Implementation(int PlayerIndexInTribe) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRequestTransferOwnershipInMyTribe_Implementation", PlayerIndexInTribe); }

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

    void ServerRequestMySpawnPoints_Implementation(int IgnoreBedID, TSubclassOf<APrimalStructure> FilterClass) { NativeCall<void, int, TSubclassOf<APrimalStructure>>(this, "AShooterPlayerState.ServerRequestMySpawnPoints_Implementation", IgnoreBedID, FilterClass); }

    void ClientReceiveSpawnPoints_Implementation(TArray<FSpawnPointInfo> * SpawnPointsInfos) { NativeCall<void, TArray<FSpawnPointInfo>*>(this, "AShooterPlayerState.ClientReceiveSpawnPoints_Implementation", SpawnPointsInfos); }

    void ServerRequestCreateNewPlayer_Implementation(FPrimalPlayerCharacterConfigStructReplicated PlayerCharacterConfig) { NativeCall<void, FPrimalPlayerCharacterConfigStructReplicated>(this, "AShooterPlayerState.ServerRequestCreateNewPlayer_Implementation", PlayerCharacterConfig); }

    void RequestCreateNewPlayerWithArkData(UPrimalPlayerData * PlayerArkData) { NativeCall<void, UPrimalPlayerData*>(this, "AShooterPlayerState.RequestCreateNewPlayerWithArkData", PlayerArkData); }

    void ServerRequestApplyEngramPoints_Implementation(TSubclassOf<UPrimalItem> forItemEntry) { NativeCall<void, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerState.ServerRequestApplyEngramPoints_Implementation", forItemEntry); }

    void ServerUnlockEngram(TSubclassOf<UPrimalItem> forItemEntry, bool bNotifyPlayerHUD, bool bForceUnlock) { NativeCall<void, TSubclassOf<UPrimalItem>, bool, bool>(this, "AShooterPlayerState.ServerUnlockEngram", forItemEntry, bNotifyPlayerHUD, bForceUnlock); }

    bool IsAlliedWith(int OtherTeam) { return NativeCall<bool, int>(this, "AShooterPlayerState.IsAlliedWith", OtherTeam); }

    bool IsFriendly(int OtherTeam) { return NativeCall<bool, int>(this, "AShooterPlayerState.IsFriendly", OtherTeam); }

    void AddEngramBlueprintToPlayerInventory(UPrimalInventoryComponent * invComp, TSubclassOf<UPrimalItem> engramItemBlueprint) { NativeCall<void, UPrimalInventoryComponent*, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerState.AddEngramBlueprintToPlayerInventory", invComp, engramItemBlueprint); }

    AShooterPlayerController * GetShooterController() { return NativeCall<AShooterPlayerController*>(this, "AShooterPlayerState.GetShooterController"); }

    UObject * GetObjectW() { return NativeCall<UObject*>(this, "AShooterPlayerState.GetObjectW"); }

    bool HasEngram(TSubclassOf<UPrimalItem> ItemClass) { return NativeCall<bool, TSubclassOf<UPrimalItem>>(this, "AShooterPlayerState.HasEngram", ItemClass); }

    void ReceivedPlayerCharacter(AShooterCharacter * NewPawn) { NativeCall<void, AShooterCharacter*>(this, "AShooterPlayerState.ReceivedPlayerCharacter", NewPawn); }

    void NotifyPlayerJoinedTribe_Implementation(FString * ThePlayerName, FString * TribeName) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerState.NotifyPlayerJoinedTribe_Implementation", ThePlayerName, TribeName); }

    void NotifyPlayerLeftTribe_Implementation(FString * ThePlayerName, FString * TribeName) { NativeCall<void, FString*, FString*>(this, "AShooterPlayerState.NotifyPlayerLeftTribe_Implementation", ThePlayerName, TribeName); }

    void NotifyPlayerJoined_Implementation(FString * ThePlayerName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyPlayerJoined_Implementation", ThePlayerName); }

    void NotifyTribememberJoined_Implementation(FString * ThePlayerName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyTribememberJoined_Implementation", ThePlayerName); }

    void NotifyPlayerLeft_Implementation(FString * ThePlayerName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyPlayerLeft_Implementation", ThePlayerName); }

    void NotifyTribememberLeft_Implementation(FString * ThePlayerName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyTribememberLeft_Implementation", ThePlayerName); }

    void NotifyUniqueDinoDownloaded_Implementation(FString * TheDinoName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyUniqueDinoDownloaded_Implementation", TheDinoName); }

    void NotifyUniqueDinoDownloadAllowed_Implementation(FString * TheDinoName) { NativeCall<void, FString*>(this, "AShooterPlayerState.NotifyUniqueDinoDownloadAllowed_Implementation", TheDinoName); }

    AShooterHUD * GetShooterHUD() { return NativeCall<AShooterHUD*>(this, "AShooterPlayerState.GetShooterHUD"); }

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

    void ServerSetDefaultItemSlotClass_Implementation(int slotNum, TSubclassOf<UPrimalItem> ItemClass, bool bIsEngram) { NativeCall<void, int, TSubclassOf<UPrimalItem>, bool>(this, "AShooterPlayerState.ServerSetDefaultItemSlotClass_Implementation", slotNum, ItemClass, bIsEngram); }

    void ClientNotifyLevelUpAvailable_Implementation() { NativeCall<void>(this, "AShooterPlayerState.ClientNotifyLevelUpAvailable_Implementation"); }

    int GetCharacterLevel() { return NativeCall<int>(this, "AShooterPlayerState.GetCharacterLevel"); }

    void SetTribeTamingDinoSettings(APrimalDinoCharacter * aDinoChar) { NativeCall<void, APrimalDinoCharacter*>(this, "AShooterPlayerState.SetTribeTamingDinoSettings", aDinoChar); }

    void SendTribeInviteData_Implementation(FTribeData TribeInviteData) { NativeCall<void, FTribeData>(this, "AShooterPlayerState.SendTribeInviteData_Implementation", TribeInviteData); }

    void DoRespec(UPrimalPlayerData * ForPlayerData, AShooterCharacter * ForCharacter, bool bSetRespecedAtCharacterLevel) { NativeCall<void, UPrimalPlayerData*, AShooterCharacter*, bool>(this, "AShooterPlayerState.DoRespec", ForPlayerData, ForCharacter, bSetRespecedAtCharacterLevel); }

    int GetTribeId() { return NativeCall<int>(this, "AShooterPlayerState.GetTribeId"); }

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

    bool IsAllowedToRefreshFlexPipeConnections(float Cooldown) { return NativeCall<bool, float>(this, "AShooterPlayerState.IsAllowedToRefreshFlexPipeConnections", Cooldown); }

    void ResetFlexPipeGlobalCooldown() { NativeCall<void>(this, "AShooterPlayerState.ResetFlexPipeGlobalCooldown"); }

    bool IsInTribeWar(int EnemyTeam) { return NativeCall<bool, int>(this, "AShooterPlayerState.IsInTribeWar", EnemyTeam); }

    bool HasTribeWarRequest(int EnemyTeam) { return NativeCall<bool, int>(this, "AShooterPlayerState.HasTribeWarRequest", EnemyTeam); }

    void ServerDeclareTribeWar_Implementation(int EnemyTeamID, int StartDayNum, int EndDayNumber, float WarStartTime, float WarEndTime) { NativeCall<void, int, int, int, float, float>(this, "AShooterPlayerState.ServerDeclareTribeWar_Implementation", EnemyTeamID, StartDayNum, EndDayNumber, WarStartTime, WarEndTime); }

    void ServerAcceptTribeWar_Implementation(int EnemyTeamID) { NativeCall<void, int>(this, "AShooterPlayerState.ServerAcceptTribeWar_Implementation", EnemyTeamID); }

    void ServerRejectTribeWar_Implementation(int EnemyTeamID) { NativeCall<void, int>(this, "AShooterPlayerState.ServerRejectTribeWar_Implementation", EnemyTeamID); }

    FTribeWar * GetTribeWar(FTribeWar * result, int EnemyTeam) { return NativeCall<FTribeWar*, FTribeWar*, int>(this, "AShooterPlayerState.GetTribeWar", result, EnemyTeam); }

    void ServerRequestRemoveAllianceMember_Implementation(unsigned int AllianceID, unsigned int MemberID) { NativeCall<void, unsigned int, unsigned int>(this, "AShooterPlayerState.ServerRequestRemoveAllianceMember_Implementation", AllianceID, MemberID); }

    void ServerRequestPromoteAllianceMember_Implementation(unsigned int AllianceID, unsigned int MemberID) { NativeCall<void, unsigned int, unsigned int>(this, "AShooterPlayerState.ServerRequestPromoteAllianceMember_Implementation", AllianceID, MemberID); }

    void ServerTribeRequestNewAlliance_Implementation(FString * AllianceName) { NativeCall<void, FString*>(this, "AShooterPlayerState.ServerTribeRequestNewAlliance_Implementation", AllianceName); }

    void ServerRequestLeaveAlliance_Implementation(unsigned int AllianceID) { NativeCall<void, unsigned int>(this, "AShooterPlayerState.ServerRequestLeaveAlliance_Implementation", AllianceID); }

    void AcceptJoinAlliance(unsigned int AllianceID, unsigned int NewMemberID, FString NewMemberName) { NativeCall<void, unsigned int, unsigned int, FString>(this, "AShooterPlayerState.AcceptJoinAlliance", AllianceID, NewMemberID, NewMemberName); }

    bool AllowTribeGroupPermission(ETribeGroupPermission::Type TribeGroupPermission, UObject * OnObject) { return NativeCall<bool, ETribeGroupPermission::Type, UObject*>(this, "AShooterPlayerState.AllowTribeGroupPermission", TribeGroupPermission, OnObject); }

    void ServerRequestSpawnPointsForDownloadedCharacters_Implementation(unsigned __int64 PlayerDataID, int IgnoreBedID) { NativeCall<