4#include <API/UE/Containers/TIndirectArray.h>
52 long double&
SpatialFrameField() {
return *GetNativePointerField<
long double*>(
this,
"UNetConnection.SpatialFrame"); }
56 int&
MaxPacketField() {
return *GetNativePointerField<
int*>(
this,
"UNetConnection.MaxPacket"); }
59 bool&
bDoneHandshakingField() {
return *GetNativePointerField<
bool*>(
this,
"UNetConnection.bDoneHandshaking"); }
65 int&
ProtocolVersionField() {
return *GetNativePointerField<
int*>(
this,
"UNetConnection.ProtocolVersion"); }
66 int&
PacketOverheadField() {
return *GetNativePointerField<
int*>(
this,
"UNetConnection.PacketOverhead"); }
69 int&
ResponseIdField() {
return *GetNativePointerField<
int*>(
this,
"UNetConnection.ResponseId"); }
70 int&
NegotiatedVerField() {
return *GetNativePointerField<
int*>(
this,
"UNetConnection.NegotiatedVer"); }
76 long double&
LastReceiveTimeField() {
return *GetNativePointerField<
long double*>(
this,
"UNetConnection.LastReceiveTime"); }
77 long double&
LastSendTimeField() {
return *GetNativePointerField<
long double*>(
this,
"UNetConnection.LastSendTime"); }
78 long double&
LastTickTimeField() {
return *GetNativePointerField<
long double*>(
this,
"UNetConnection.LastTickTime"); }
79 int&
QueuedBytesField() {
return *GetNativePointerField<
int*>(
this,
"UNetConnection.QueuedBytes"); }
80 int&
TickCountField() {
return *GetNativePointerField<
int*>(
this,
"UNetConnection.TickCount"); }
81 float&
LastRecvAckTimeField() {
return *GetNativePointerField<
float*>(
this,
"UNetConnection.LastRecvAckTime"); }
82 float&
ConnectTimeField() {
return *GetNativePointerField<
float*>(
this,
"UNetConnection.ConnectTime"); }
85 bool&
AllowMergeField() {
return *GetNativePointerField<
bool*>(
this,
"UNetConnection.AllowMerge"); }
86 bool&
TimeSensitiveField() {
return *GetNativePointerField<
bool*>(
this,
"UNetConnection.TimeSensitive"); }
87 long double&
StatUpdateTimeField() {
return *GetNativePointerField<
long double*>(
this,
"UNetConnection.StatUpdateTime"); }
88 float&
StatPeriodField() {
return *GetNativePointerField<
float*>(
this,
"UNetConnection.StatPeriod"); }
89 float&
BestLagField() {
return *GetNativePointerField<
float*>(
this,
"UNetConnection.BestLag"); }
90 float&
AvgLagField() {
return *GetNativePointerField<
float*>(
this,
"UNetConnection.AvgLag"); }
91 float&
LagAccField() {
return *GetNativePointerField<
float*>(
this,
"UNetConnection.LagAcc"); }
92 float&
BestLagAccField() {
return *GetNativePointerField<
float*>(
this,
"UNetConnection.BestLagAcc"); }
93 int&
LagCountField() {
return *GetNativePointerField<
int*>(
this,
"UNetConnection.LagCount"); }
94 long double&
LastTimeField() {
return *GetNativePointerField<
long double*>(
this,
"UNetConnection.LastTime"); }
95 long double&
FrameTimeField() {
return *GetNativePointerField<
long double*>(
this,
"UNetConnection.FrameTime"); }
96 long double&
CumulativeTimeField() {
return *GetNativePointerField<
long double*>(
this,
"UNetConnection.CumulativeTime"); }
97 long double&
AverageFrameTimeField() {
return *GetNativePointerField<
long double*>(
this,
"UNetConnection.AverageFrameTime"); }
98 int&
CountedFramesField() {
return *GetNativePointerField<
int*>(
this,
"UNetConnection.CountedFrames"); }
99 int&
InBytesField() {
return *GetNativePointerField<
int*>(
this,
"UNetConnection.InBytes"); }
100 int&
OutBytesField() {
return *GetNativePointerField<
int*>(
this,
"UNetConnection.OutBytes"); }
101 int&
InPacketsLostField() {
return *GetNativePointerField<
int*>(
this,
"UNetConnection.InPacketsLost"); }
102 int&
OutPacketsLostField() {
return *GetNativePointerField<
int*>(
this,
"UNetConnection.OutPacketsLost"); }
106 int&
InPacketIdField() {
return *GetNativePointerField<
int*>(
this,
"UNetConnection.InPacketId"); }
107 int&
OutPacketIdField() {
return *GetNativePointerField<
int*>(
this,
"UNetConnection.OutPacketId"); }
108 int&
OutAckPacketIdField() {
return *GetNativePointerField<
int*>(
this,
"UNetConnection.OutAckPacketId"); }
112 float&
LastPingAckField() {
return *GetNativePointerField<
float*>(
this,
"UNetConnection.LastPingAck"); }
119 long double&
LogCallLastTimeField() {
return *GetNativePointerField<
long double*>(
this,
"UNetConnection.LogCallLastTime"); }
120 int&
LogCallCountField() {
return *GetNativePointerField<
int*>(
this,
"UNetConnection.LogCallCount"); }
127 float&
DormancyRateField() {
return *GetNativePointerField<
float*>(
this,
"UNetConnection.DormancyRate"); }
153 UActorChannel*
ActorChannelsFindRef(
AActor* InActor,
bool bUseWeak) {
return NativeCall<UActorChannel*,
AActor*,
bool>(
this,
"UNetConnection.ActorChannelsFindRef", InActor, bUseWeak); }
155 void CleanUp() { NativeCall<
void>(
this,
"UNetConnection.CleanUp"); }
158 void Close() { NativeCall<
void>(
this,
"UNetConnection.Close"); }
159 void FinishDestroy() { NativeCall<
void>(
this,
"UNetConnection.FinishDestroy"); }
161 void FlushNet(
bool bIgnoreSimulation) { NativeCall<
void,
bool>(
this,
"UNetConnection.FlushNet", bIgnoreSimulation); }
165 void InitSendBuffer() { NativeCall<
void>(
this,
"UNetConnection.InitSendBuffer"); }
166 bool IsClientMsgTypeValid(
const char ClientMsgType) {
return NativeCall<
bool,
const char>(
this,
"UNetConnection.IsClientMsgTypeValid", ClientMsgType); }
167 int IsNetReady(
bool Saturate) {
return NativeCall<
int,
bool>(
this,
"UNetConnection.IsNetReady", Saturate); }
170 void LowLevelSend(
void* Data,
int Count) { NativeCall<
void,
void*,
int>(
this,
"UNetConnection.LowLevelSend", Data, Count); }
171 void PurgeAcks() { NativeCall<
void>(
this,
"UNetConnection.PurgeAcks"); }
172 void ReceivedNak(
int NakPacketId) { NativeCall<
void,
int>(
this,
"UNetConnection.ReceivedNak", NakPacketId); }
173 void ReceivedNak_Range(
int NakPacketStart,
int NakPacketEnd) { NativeCall<
void,
int,
int>(
this,
"UNetConnection.ReceivedNak_Range", NakPacketStart, NakPacketEnd); }
175 void ReceivedRawPacket(
void* InData,
int Count) { NativeCall<
void,
void*,
int>(
this,
"UNetConnection.ReceivedRawPacket", InData, Count); }
177 void SendAck(
int AckPacketId,
bool FirstTime,
bool bHavePingAckData,
unsigned int PingAckData) { NativeCall<
void,
int,
bool,
bool,
unsigned int>(
this,
"UNetConnection.SendAck", AckPacketId, FirstTime, bHavePingAckData, PingAckData); }
178 void SendPackageMap() { NativeCall<
void>(
this,
"UNetConnection.SendPackageMap"); }
182 void Tick() { NativeCall<
void>(
this,
"UNetConnection.Tick"); }
184 int WriteBitsToSendBuffer(
const char* Bits,
const int SizeInBits,
const char* ExtraBits,
const int ExtraSizeInBits) {
return NativeCall<
int,
const char*,
const int,
const char*,
const int>(
this,
"UNetConnection.WriteBitsToSendBuffer", Bits, SizeInBits, ExtraBits, ExtraSizeInBits); }
197 bool ExportTextItem(
FString* ValueStr,
FUniqueNetIdRepl* DefaultValue,
UObject* Parent,
int PortFlags,
UObject* ExportRootScope) {
return NativeCall<
bool,
FString*,
FUniqueNetIdRepl*,
UObject*,
int,
UObject*>(
this,
"FUniqueNetIdRepl.ExportTextItem", ValueStr, DefaultValue, Parent, PortFlags, ExportRootScope); }
243 bool&
bUsedField() {
return *GetNativePointerField<
bool*>(
this,
"FPrimalStats.bUsed"); }
244 long double&
StartStatsTimeField() {
return *GetNativePointerField<
long double*>(
this,
"FPrimalStats.StartStatsTime"); }
254 unsigned int&
EntityIDField() {
return *GetNativePointerField<
unsigned int*>(
this,
"FSpawnPointInfo.EntityID"); }
256 bool&
bServerIsFullField() {
return *GetNativePointerField<
bool*>(
this,
"FSpawnPointInfo.bServerIsFull"); }
259 unsigned int&
ServerIdField() {
return *GetNativePointerField<
unsigned int*>(
this,
"FSpawnPointInfo.ServerId"); }
261 unsigned int&
NextAllowedUseTimeField() {
return *GetNativePointerField<
unsigned int*>(
this,
"FSpawnPointInfo.NextAllowedUseTime"); }
262 unsigned int&
ParentEntityIDField() {
return *GetNativePointerField<
unsigned int*>(
this,
"FSpawnPointInfo.ParentEntityID"); }
265 bool&
bIsDeadField() {
return *GetNativePointerField<
bool*>(
this,
"FSpawnPointInfo.bIsDead"); }
279 __int64&
LinkedPlayerIDField() {
return *GetNativePointerField<
__int64*>(
this,
"FAdminPlayerDataInfo.LinkedPlayerID"); }
280 bool&
IsHostField() {
return *GetNativePointerField<
bool*>(
this,
"FAdminPlayerDataInfo.IsHost"); }
289 int&
PlayerIDField() {
return *GetNativePointerField<
int*>(
this,
"FPlayerDeathReason.PlayerID"); }
291 long double&
DiedAtTimeField() {
return *GetNativePointerField<
long double*>(
this,
"FPlayerDeathReason.DiedAtTime"); }
303 char&
FacialHairIndexField() {
return *GetNativePointerField<
char*>(
this,
"FPrimalPlayerCharacterConfigStruct.FacialHairIndex"); }
304 char&
HeadHairIndexField() {
return *GetNativePointerField<
char*>(
this,
"FPrimalPlayerCharacterConfigStruct.HeadHairIndex"); }
310 float&
BodyfatField() {
return *GetNativePointerField<
float*>(
this,
"FPrimalPlayerCharacterConfigStruct.Bodyfat"); }
311 float&
AgeField() {
return *GetNativePointerField<
float*>(
this,
"FPrimalPlayerCharacterConfigStruct.Age"); }
312 float&
MuscleToneField() {
return *GetNativePointerField<
float*>(
this,
"FPrimalPlayerCharacterConfigStruct.MuscleTone"); }
329 float&
AmountToAddField() {
return *GetNativePointerField<
float*>(
this,
"FPrimalCharacterStatusValueModifier.AmountToAdd"); }
330 float&
BaseAmountToAddField() {
return *GetNativePointerField<
float*>(
this,
"FPrimalCharacterStatusValueModifier.BaseAmountToAdd"); }
331 float&
SpeedToAddField() {
return *GetNativePointerField<
float*>(
this,
"FPrimalCharacterStatusValueModifier.SpeedToAdd"); }
350 float&
EntryWeightField() {
return *GetNativePointerField<
float*>(
this,
"FDinoBaseLevelWeightEntry.EntryWeight"); }
351 float&
BaseLevelMinRangeField() {
return *GetNativePointerField<
float*>(
this,
"FDinoBaseLevelWeightEntry.BaseLevelMinRange"); }
352 float&
BaseLevelMaxRangeField() {
return *GetNativePointerField<
float*>(
this,
"FDinoBaseLevelWeightEntry.BaseLevelMaxRange"); }
435 static UClass*
GetPrivateStaticClass(
const wchar_t* Package) {
return NativeCall<
UClass*,
const wchar_t*>(
nullptr,
"UNPCSpawnEntriesContainer.GetPrivateStaticClass", Package); }
485 void AddLocalOffset(
FVector DeltaLocation,
bool bSweep) { NativeCall<
void,
FVector,
bool>(
this,
"USceneComponent.AddLocalOffset", DeltaLocation, bSweep); }
488 void AddWorldOffset(
FVector DeltaLocation,
bool bSweep) { NativeCall<
void,
FVector,
bool>(
this,
"USceneComponent.AddWorldOffset", DeltaLocation, bSweep); }
492 void ApplyWorldOffset(
FVector* InOffset,
bool bWorldShift) { NativeCall<
void,
FVector*,
bool>(
this,
"USceneComponent.ApplyWorldOffset", InOffset, bWorldShift); }
493 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); }
494 void BeginDestroy() { NativeCall<
void>(
this,
"USceneComponent.BeginDestroy"); }
495 void CalcBoundingCylinder(
float* CylinderRadius,
float* CylinderHalfHeight) { NativeCall<
void,
float*,
float*>(
this,
"USceneComponent.CalcBoundingCylinder", CylinderRadius, CylinderHalfHeight); }
498 bool CanEverRender() {
return NativeCall<
bool>(
this,
"USceneComponent.CanEverRender"); }
500 void DetachFromParent(
bool bMaintainWorldPosition) { NativeCall<
void,
bool>(
this,
"USceneComponent.DetachFromParent", bMaintainWorldPosition); }
501 unsigned __int64 GetAttachParent() {
return NativeCall<
unsigned __int64>(
this,
"USceneComponent.GetAttachParent"); }
517 FQuat*
GetSocketQuaternion(FQuat* result,
FName SocketName) {
return NativeCall<FQuat*, FQuat*,
FName>(
this,
"USceneComponent.GetSocketQuaternion", result, SocketName); }
528 bool IsVisible() {
return NativeCall<
bool>(
this,
"USceneComponent.IsVisible"); }
529 bool IsVisibleInEditor() {
return NativeCall<
bool>(
this,
"USceneComponent.IsVisibleInEditor"); }
530 void K2_AttachTo(
USceneComponent* InParent,
FName InSocketName,
EAttachLocation::
Type AttachLocationType,
bool bWeldSimulatedBodies) { NativeCall<
void,
USceneComponent*,
FName,
EAttachLocation::
Type,
bool>(
this,
"USceneComponent.K2_AttachTo", InParent, InSocketName, AttachLocationType, bWeldSimulatedBodies); }
534 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); }
535 void OnRegister() { NativeCall<
void>(
this,
"USceneComponent.OnRegister"); }
537 void OnRep_Visibility(
bool OldValue) { NativeCall<
void,
bool>(
this,
"USceneComponent.OnRep_Visibility", OldValue); }
539 void PostNetReceive() { NativeCall<
void>(
this,
"USceneComponent.PostNetReceive"); }
540 void PreNetReceive() { NativeCall<
void>(
this,
"USceneComponent.PreNetReceive"); }
542 void SetAbsolute(
bool bNewAbsoluteLocation,
bool bNewAbsoluteRotation,
bool bNewAbsoluteScale) { NativeCall<
void,
bool,
bool,
bool>(
this,
"USceneComponent.SetAbsolute", bNewAbsoluteLocation, bNewAbsoluteRotation, bNewAbsoluteScale); }
543 void SetHiddenInGame(
bool NewHiddenGame,
bool bPropagateToChildren) { NativeCall<
void,
bool,
bool>(
this,
"USceneComponent.SetHiddenInGame", NewHiddenGame, bPropagateToChildren); }
548 void SetVisibility(
bool bNewVisibility,
bool bPropagateToChildren) { NativeCall<
void,
bool,
bool>(
this,
"USceneComponent.SetVisibility", bNewVisibility, bPropagateToChildren); }
550 void SetWorldLocationAndRotation(
FVector NewLocation, FQuat* NewRotation,
bool bSweep) { NativeCall<
void,
FVector, FQuat*,
bool>(
this,
"USceneComponent.SetWorldLocationAndRotation", NewLocation, NewRotation, bSweep); }
553 void SetWorldRotation(FQuat* NewRotation,
bool bSweep) { NativeCall<
void, FQuat*,
bool>(
this,
"USceneComponent.SetWorldRotation", NewRotation, bSweep); }
557 bool ShouldRender() {
return NativeCall<
bool>(
this,
"USceneComponent.ShouldRender"); }
559 void StopSound(USoundBase* SoundToStop,
float FadeOutTime) { NativeCall<
void, USoundBase*,
float>(
this,
"USceneComponent.StopSound", SoundToStop, FadeOutTime); }
560 void ToggleVisibility(
bool bPropagateToChildren) { NativeCall<
void,
bool>(
this,
"USceneComponent.ToggleVisibility", bPropagateToChildren); }
561 void UpdateBounds() { NativeCall<
void>(
this,
"USceneComponent.UpdateBounds"); }
563 void UpdateComponentToWorld(
bool bSkipPhysicsMove) { NativeCall<
void,
bool>(
this,
"USceneComponent.UpdateComponentToWorld", bSkipPhysicsMove); }
566 void UpdatePhysicsVolume(
bool bTriggerNotifiers) { NativeCall<
void,
bool>(
this,
"USceneComponent.UpdatePhysicsVolume", bTriggerNotifiers); }
573 float&
MinDrawDistanceField() {
return *GetNativePointerField<
float*>(
this,
"UPrimitiveComponent.MinDrawDistance"); }
575 float&
LDMaxDrawDistanceField() {
return *GetNativePointerField<
float*>(
this,
"UPrimitiveComponent.LDMaxDrawDistance"); }
585 int&
ObjectLayerField() {
return *GetNativePointerField<
int*>(
this,
"UPrimitiveComponent.ObjectLayer"); }
592 int&
VisibilityIdField() {
return *GetNativePointerField<
int*>(
this,
"UPrimitiveComponent.VisibilityId"); }
597 float&
LpvBiasMultiplierField() {
return *GetNativePointerField<
float*>(
this,
"UPrimitiveComponent.LpvBiasMultiplier"); }
602 float&
BoundsScaleField() {
return *GetNativePointerField<
float*>(
this,
"UPrimitiveComponent.BoundsScale"); }
603 long double&
LastSubmitTimeField() {
return *GetNativePointerField<
long double*>(
this,
"UPrimitiveComponent.LastSubmitTime"); }
604 long double&
LastRenderTimeField() {
return *GetNativePointerField<
long double*>(
this,
"UPrimitiveComponent.LastRenderTime"); }
608 FComponentBeginOverlapSignature&
OnComponentBeginOverlapField() {
return *GetNativePointerField<FComponentBeginOverlapSignature*>(
this,
"UPrimitiveComponent.OnComponentBeginOverlap"); }
609 FComponentEndOverlapSignature&
OnComponentEndOverlapField() {
return *GetNativePointerField<FComponentEndOverlapSignature*>(
this,
"UPrimitiveComponent.OnComponentEndOverlap"); }
610 FComponentBeginCursorOverSignature&
OnBeginCursorOverField() {
return *GetNativePointerField<FComponentBeginCursorOverSignature*>(
this,
"UPrimitiveComponent.OnBeginCursorOver"); }
611 FComponentEndCursorOverSignature&
OnEndCursorOverField() {
return *GetNativePointerField<FComponentEndCursorOverSignature*>(
this,
"UPrimitiveComponent.OnEndCursorOver"); }
612 FComponentOnClickedSignature&
OnClickedField() {
return *GetNativePointerField<FComponentOnClickedSignature*>(
this,
"UPrimitiveComponent.OnClicked"); }
613 FComponentOnReleasedSignature&
OnReleasedField() {
return *GetNativePointerField<FComponentOnReleasedSignature*>(
this,
"UPrimitiveComponent.OnReleased"); }
614 FComponentOnInputTouchBeginSignature&
OnInputTouchBeginField() {
return *GetNativePointerField<FComponentOnInputTouchBeginSignature*>(
this,
"UPrimitiveComponent.OnInputTouchBegin"); }
615 FComponentOnInputTouchEndSignature&
OnInputTouchEndField() {
return *GetNativePointerField<FComponentOnInputTouchEndSignature*>(
this,
"UPrimitiveComponent.OnInputTouchEnd"); }
616 FComponentBeginTouchOverSignature&
OnInputTouchEnterField() {
return *GetNativePointerField<FComponentBeginTouchOverSignature*>(
this,
"UPrimitiveComponent.OnInputTouchEnter"); }
617 FComponentEndTouchOverSignature&
OnInputTouchLeaveField() {
return *GetNativePointerField<FComponentEndTouchOverSignature*>(
this,
"UPrimitiveComponent.OnInputTouchLeave"); }
618 unsigned int&
ProxyMeshIDField() {
return *GetNativePointerField<
unsigned int*>(
this,
"UPrimitiveComponent.ProxyMeshID"); }
696 void GetLightAndShadowMapMemoryUsage(
int* NumInstances,
float* BoundsSurfaceArea) { NativeCall<
void,
int*,
float*>(
this,
"UPrimitiveComponent.GetLightAndShadowMapMemoryUsage", NumInstances, BoundsSurfaceArea); }
698 void BeginDestroy() { NativeCall<
void>(
this,
"UPrimitiveComponent.BeginDestroy"); }
702 bool ComponentOverlapComponentImpl(
UPrimitiveComponent* PrimComp,
FVector Pos, FQuat* Quat,
FCollisionQueryParams* Params) {
return NativeCall<
bool,
UPrimitiveComponent*,
FVector, FQuat*,
FCollisionQueryParams*>(
this,
"UPrimitiveComponent.ComponentOverlapComponentImpl", PrimComp, Pos, Quat, Params); }
715 void FinishDestroy() { NativeCall<
void>(
this,
"UPrimitiveComponent.FinishDestroy"); }
722 bool HasStaticLighting() {
return NativeCall<
bool>(
this,
"UPrimitiveComponent.HasStaticLighting"); }
726 void InvalidateLightingCacheDetailed(
bool bInvalidateBuildEnqueuedLighting,
bool bTranslationOnly) { NativeCall<
void,
bool,
bool>(
this,
"UPrimitiveComponent.InvalidateLightingCacheDetailed", bInvalidateBuildEnqueuedLighting, bTranslationOnly); }
727 bool IsEditorOnly() {
return NativeCall<
bool>(
this,
"UPrimitiveComponent.IsEditorOnly"); }
732 bool IsWorldGeometry() {
return NativeCall<
bool>(
this,
"UPrimitiveComponent.IsWorldGeometry"); }
733 bool LineTraceComponent(
FHitResult* OutHit,
FVector Start,
FVector End,
FCollisionQueryParams* Params) {
return NativeCall<
bool,
FHitResult*,
FVector,
FVector,
FCollisionQueryParams*>(
this,
"UPrimitiveComponent.LineTraceComponent", OutHit, Start, End, Params); }
734 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); }
735 bool NeedsLoadForClient() {
return NativeCall<
bool>(
this,
"UPrimitiveComponent.NeedsLoadForClient"); }
736 bool NeedsLoadForServer() {
return NativeCall<
bool>(
this,
"UPrimitiveComponent.NeedsLoadForServer"); }
738 void OnRegister() { NativeCall<
void>(
this,
"UPrimitiveComponent.OnRegister"); }
739 void OnUnregister() { NativeCall<
void>(
this,
"UPrimitiveComponent.OnUnregister"); }
740 void OnUpdateTransform(
bool bSkipPhysicsMove) { NativeCall<
void,
bool>(
this,
"UPrimitiveComponent.OnUpdateTransform", bSkipPhysicsMove); }
741 void PostDuplicate(
bool bDuplicateForPIE) { NativeCall<
void,
bool>(
this,
"UPrimitiveComponent.PostDuplicate", bDuplicateForPIE); }
742 void PostLoad() { NativeCall<
void>(
this,
"UPrimitiveComponent.PostLoad"); }
744 void RegisterComponentTickFunctions(
bool bRegister,
bool bSaveAndRestoreComponentTickState) { NativeCall<
void,
bool,
bool>(
this,
"UPrimitiveComponent.RegisterComponentTickFunctions", bRegister, bSaveAndRestoreComponentTickState); }
745 void SendPhysicsTransform(
bool bTeleport) { NativeCall<
void,
bool>(
this,
"UPrimitiveComponent.SendPhysicsTransform", bTeleport); }
747 void SetAbsoluteMaxDrawScale(
bool bInValue) { NativeCall<
void,
bool>(
this,
"UPrimitiveComponent.SetAbsoluteMaxDrawScale", bInValue); }
748 void SetCanEverAffectNavigation(
bool bRelevant) { NativeCall<
void,
bool>(
this,
"UPrimitiveComponent.SetCanEverAffectNavigation", bRelevant); }
749 void SetCastShadow(
bool NewCastShadow) { NativeCall<
void,
bool>(
this,
"UPrimitiveComponent.SetCastShadow", NewCastShadow); }
750 void SetCullDistance(
float NewCullDistance) { NativeCall<
void,
float>(
this,
"UPrimitiveComponent.SetCullDistance", NewCullDistance); }
753 void SetOnlyOwnerSee(
bool bNewOnlyOwnerSee) { NativeCall<
void,
bool>(
this,
"UPrimitiveComponent.SetOnlyOwnerSee", bNewOnlyOwnerSee); }
754 void SetOwnerNoSee(
bool bNewOwnerNoSee) { NativeCall<
void,
bool>(
this,
"UPrimitiveComponent.SetOwnerNoSee", bNewOwnerNoSee); }
755 void SetRenderCustomDepth(
bool bValue) { NativeCall<
void,
bool>(
this,
"UPrimitiveComponent.SetRenderCustomDepth", bValue); }
756 void SetTranslucentSortPriority(
int NewTranslucentSortPriority) { NativeCall<
void,
int>(
this,
"UPrimitiveComponent.SetTranslucentSortPriority", NewTranslucentSortPriority); }
760 void UpdatePhysicsVolume(
bool bTriggerNotifiers) { NativeCall<
void,
bool>(
this,
"UPrimitiveComponent.UpdatePhysicsVolume", bTriggerNotifiers); }
762 bool WasRecentlyVisible() {
return NativeCall<
bool>(
this,
"UPrimitiveComponent.WasRecentlyVisible"); }
763 void AddForce(
FVector Force,
FName BoneName,
bool bAllowSubstepping) { NativeCall<
void,
FVector,
FName,
bool>(
this,
"UPrimitiveComponent.AddForce", Force, BoneName, bAllowSubstepping); }
764 void AddForceAtLocation(
FVector Force,
FVector Location,
FName BoneName,
bool bAllowSubstepping) { NativeCall<
void,
FVector,
FVector,
FName,
bool>(
this,
"UPrimitiveComponent.AddForceAtLocation", Force, Location, BoneName, bAllowSubstepping); }
767 void AddRadialForce(
FVector Origin,
float Radius,
float Strength,
ERadialImpulseFalloff Falloff) { NativeCall<
void,
FVector,
float,
float,
ERadialImpulseFalloff>(
this,
"UPrimitiveComponent.AddRadialForce", Origin, Radius, Strength, Falloff); }
768 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); }
769 void AddTorque(
FVector Torque,
FName BoneName,
bool bAllowSubstepping) { NativeCall<
void,
FVector,
FName,
bool>(
this,
"UPrimitiveComponent.AddTorque", Torque, BoneName, bAllowSubstepping); }
771 float GetAngularDamping() {
return NativeCall<
float>(
this,
"UPrimitiveComponent.GetAngularDamping"); }
780 float GetLinearDamping() {
return NativeCall<
float>(
this,
"UPrimitiveComponent.GetLinearDamping"); }
781 float GetMass() {
return NativeCall<
float>(
this,
"UPrimitiveComponent.GetMass"); }
785 FWalkableSlopeOverride*
GetWalkableSlopeOverride() {
return NativeCall<FWalkableSlopeOverride*>(
this,
"UPrimitiveComponent.GetWalkableSlopeOverride"); }
788 bool IsGravityEnabled() {
return NativeCall<
bool>(
this,
"UPrimitiveComponent.IsGravityEnabled"); }
790 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); }
791 void OnActorEnableCollisionChanged(
bool bCheckRecreatePhysicsState) { NativeCall<
void,
bool>(
this,
"UPrimitiveComponent.OnActorEnableCollisionChanged", bCheckRecreatePhysicsState); }
800 void SetAngularDamping(
float InDamping) { NativeCall<
void,
float>(
this,
"UPrimitiveComponent.SetAngularDamping", InDamping); }
807 void SetEnableGravity(
bool bGravityEnabled) { NativeCall<
void,
bool>(
this,
"UPrimitiveComponent.SetEnableGravity", bGravityEnabled); }
808 void SetLinearDamping(
float InDamping) { NativeCall<
void,
float>(
this,
"UPrimitiveComponent.SetLinearDamping", InDamping); }
809 void SetNotifyRigidBodyCollision(
bool bNewNotifyRigidBodyCollision) { NativeCall<
void,
bool>(
this,
"UPrimitiveComponent.SetNotifyRigidBodyCollision", bNewNotifyRigidBodyCollision); }
813 void SetPhysicsMaxAngularVelocity(
float NewMaxAngVel,
bool bAddToCurrent,
FName BoneName) { NativeCall<
void,
float,
bool,
FName>(
this,
"UPrimitiveComponent.SetPhysicsMaxAngularVelocity", NewMaxAngVel, bAddToCurrent, BoneName); }
814 void SetSimulatePhysics(
bool bSimulate) { NativeCall<
void,
bool>(
this,
"UPrimitiveComponent.SetSimulatePhysics", bSimulate); }
816 void UnWeldFromParent() { NativeCall<
void>(
this,
"UPrimitiveComponent.UnWeldFromParent"); }
821 void SetInternalOctreeMask(
int InOctreeMask,
bool bReregisterWithTree) { NativeCall<
void,
int,
bool>(
this,
"UPrimitiveComponent.SetInternalOctreeMask", InOctreeMask, bReregisterWithTree); }
829 UMaterialInterface*
ShapeMaterialField() {
return *GetNativePointerField<UMaterialInterface**>(
this,
"UShapeComponent.ShapeMaterial"); }
844 float&
SphereRadiusField() {
return *GetNativePointerField<
float*>(
this,
"USphereComponent.SphereRadius"); }
849 void CalcBoundingCylinder(
float* CylinderRadius,
float* CylinderHalfHeight) { NativeCall<
void,
float*,
float*>(
this,
"USphereComponent.CalcBoundingCylinder", CylinderRadius, CylinderHalfHeight); }
851 bool IsZeroExtent() {
return NativeCall<
bool>(
this,
"USphereComponent.IsZeroExtent"); }
853 void SetSphereRadius(
float InSphereRadius,
bool bUpdateOverlaps) { NativeCall<
void,
float,
bool>(
this,
"USphereComponent.SetSphereRadius", InSphereRadius, bUpdateOverlaps); }
854 void UpdateBodySetup() { NativeCall<
void>(
this,
"USphereComponent.UpdateBodySetup"); }
885 int&
CustomDataField() {
return *GetNativePointerField<
int*>(
this,
"AActor.CustomData"); }
890 unsigned __int64&
LastFrameUnStasisField() {
return *GetNativePointerField<
unsigned __int64*>(
this,
"AActor.LastFrameUnStasis"); }
895 int&
NetTagField() {
return *GetNativePointerField<
int*>(
this,
"AActor.NetTag"); }
896 long double&
NetUpdateTimeField() {
return *GetNativePointerField<
long double*>(
this,
"AActor.NetUpdateTime"); }
898 float&
NetPriorityField() {
return *GetNativePointerField<
float*>(
this,
"AActor.NetPriority"); }
901 unsigned int&
UniqueActorIdField() {
return *GetNativePointerField<
unsigned int*>(
this,
"AActor.UniqueActorId"); }
905 long double&
CreationTimeField() {
return *GetNativePointerField<
long double*>(
this,
"AActor.CreationTime"); }
916 long double&
LastRenderTimeField() {
return *GetNativePointerField<
long double*>(
this,
"AActor.LastRenderTime"); }
919 unsigned __int64&
HiddenEditorViewsField() {
return *GetNativePointerField<
unsigned __int64*>(
this,
"AActor.HiddenEditorViews"); }
1043 bool HasAuthority() {
return NativeCall<
bool>(
this,
"AActor.HasAuthority"); }
1053 UActorComponent*
AddComponent(
FName TemplateName,
bool bManualAttachment,
FTransform* RelativeTransform,
UObject* ComponentTemplateContext) {
return NativeCall<
UActorComponent*,
FName,
bool,
FTransform*,
UObject*>(
this,
"AActor.AddComponent", TemplateName, bManualAttachment, RelativeTransform, ComponentTemplateContext); }
1058 bool AllowSaving() {
return NativeCall<
bool>(
this,
"AActor.AllowSaving"); }
1061 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); }
1062 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); }
1068 void BeginPlay() { NativeCall<
void>(
this,
"AActor.BeginPlay"); }
1069 void CalcCamera(
float DeltaTime, FMinimalViewInfo* OutResult) { NativeCall<
void,
float, FMinimalViewInfo*>(
this,
"AActor.CalcCamera", DeltaTime, OutResult); }
1070 void ChangeActorTeam(
int NewTeam) { NativeCall<
void,
int>(
this,
"AActor.ChangeActorTeam", NewTeam); }
1081 bool Destroy(
bool bNetForce,
bool bShouldModifyLevel) {
return NativeCall<
bool,
bool,
bool>(
this,
"AActor.Destroy", bNetForce, bShouldModifyLevel); }
1086 void Destroyed() { NativeCall<
void>(
this,
"AActor.Destroyed"); }
1087 void DetachRootComponentFromParent(
bool bMaintainWorldPosition) { NativeCall<
void,
bool>(
this,
"AActor.DetachRootComponentFromParent", bMaintainWorldPosition); }
1091 void DispatchBlockingHit(
UPrimitiveComponent* MyComp,
UPrimitiveComponent* OtherComp,
bool bSelfMoved,
FHitResult* Hit) { NativeCall<
void,
UPrimitiveComponent*,
UPrimitiveComponent*,
bool,
FHitResult*>(
this,
"AActor.DispatchBlockingHit", MyComp, OtherComp, bSelfMoved, Hit); }
1096 void ExchangeNetRoles(
bool bRemoteOwned) { NativeCall<
void,
bool>(
this,
"AActor.ExchangeNetRoles", bRemoteOwned); }
1123 void GetComponentsBoundingCylinder(
float* OutCollisionRadius,
float* OutCollisionHalfHeight,
bool bNonColliding) { NativeCall<
void,
float*,
float*,
bool>(
this,
"AActor.GetComponentsBoundingCylinder", OutCollisionRadius, OutCollisionHalfHeight, bNonColliding); }
1129 FString*
GetEditTextString_Implementation(
FString* result,
APlayerController* ForPC,
UObject* AssociatedObject1,
int ExtraID1,
int ExtraID2) {
return NativeCall<
FString*,
FString*,
APlayerController*,
UObject*,
int,
int>(
this,
"AActor.GetEditTextString_Implementation", result, ForPC, AssociatedObject1, ExtraID1, ExtraID2); }
1141 long double GetLastRenderTime(
bool ignoreShadow) {
return NativeCall<
long double,
bool>(
this,
"AActor.GetLastRenderTime", ignoreShadow); }
1142 float GetLifeSpan() {
return NativeCall<
float>(
this,
"AActor.GetLifeSpan"); }
1146 float GetNetPriority(
FVector* ViewPos,
FVector* ViewDir,
APlayerController* Viewer, UActorChannel* InChannel,
float Time,
bool bLowBandwidth) {
return NativeCall<
float,
FVector*,
FVector*,
APlayerController*, UActorChannel*,
float,
bool>(
this,
"AActor.GetNetPriority", ViewPos, ViewDir, Viewer, InChannel, Time, bLowBandwidth); }
1152 void GetSimpleCollisionCylinder(
float* CollisionRadius,
float* CollisionHalfHeight) { NativeCall<
void,
float*,
float*>(
this,
"AActor.GetSimpleCollisionCylinder", CollisionRadius, CollisionHalfHeight); }
1161 bool HasNetOwner() {
return NativeCall<
bool>(
this,
"AActor.HasNetOwner"); }
1163 float InternalTakeRadialDamage(
float Damage,
FRadialDamageEvent* RadialDamageEvent,
AController* EventInstigator,
AActor* DamageCauser) {
return NativeCall<
float,
float,
FRadialDamageEvent*,
AController*,
AActor*>(
this,
"AActor.InternalTakeRadialDamage", Damage, RadialDamageEvent, EventInstigator, DamageCauser); }
1171 bool IsInPersistentLevel(
bool bIncludeLevelStreamingPersistent) {
return NativeCall<
bool,
bool>(
this,
"AActor.IsInPersistentLevel", bIncludeLevelStreamingPersistent); }
1183 void K2_AttachRootComponentTo(
USceneComponent* InParent,
FName InSocketName,
EAttachLocation::
Type AttachLocationType,
bool bWeldSimulatedBodies) { NativeCall<
void,
USceneComponent*,
FName,
EAttachLocation::
Type,
bool>(
this,
"AActor.K2_AttachRootComponentTo", InParent, InSocketName, AttachLocationType, bWeldSimulatedBodies); }
1184 void K2_AttachRootComponentToActor(
AActor* InParentActor,
FName InSocketName,
EAttachLocation::
Type AttachLocationType,
bool bWeldSimulatedBodies) { NativeCall<
void,
AActor*,
FName,
EAttachLocation::
Type,
bool>(
this,
"AActor.K2_AttachRootComponentToActor", InParentActor, InSocketName, AttachLocationType, bWeldSimulatedBodies); }
1192 void MakeNoise(
float Loudness,
APawn* NoiseInstigator,
FVector NoiseLocation) { NativeCall<
void,
float,
APawn*,
FVector>(
this,
"AActor.MakeNoise", Loudness, NoiseInstigator, NoiseLocation); }
1193 static void MakeNoiseImpl(
AActor* NoiseMaker,
float Loudness,
APawn* NoiseInstigator,
FVector* NoiseLocation) { NativeCall<
void,
AActor*,
float,
APawn*,
FVector*>(
nullptr,
"AActor.MakeNoiseImpl", NoiseMaker, Loudness, NoiseInstigator, NoiseLocation); }
1197 bool Modify(
bool bAlwaysMarkDirty) {
return NativeCall<
bool,
bool>(
this,
"AActor.Modify", bAlwaysMarkDirty); }
1198 void Multi_DrawDebugCoordinateSystem_Implementation(
FVector AxisLoc,
FRotator AxisRot,
float Scale,
bool bPersistentLines,
float LifeTime,
char DepthPriority,
float Thickness) { NativeCall<
void,
FVector,
FRotator,
float,
bool,
float,
char,
float>(
this,
"AActor.Multi_DrawDebugCoordinateSystem_Implementation", AxisLoc, AxisRot, Scale, bPersistentLines, LifeTime, DepthPriority, Thickness); }
1199 void Multi_DrawDebugDirectionalArrow_Implementation(
FVector LineStart,
FVector LineEnd,
float ArrowSize,
FColor ArrowColor,
bool bPersistentLines,
float LifeTime,
char DepthPriority) { NativeCall<
void,
FVector,
FVector,
float,
FColor,
bool,
float,
char>(
this,
"AActor.Multi_DrawDebugDirectionalArrow_Implementation", LineStart, LineEnd, ArrowSize, ArrowColor, bPersistentLines, LifeTime, DepthPriority); }
1200 void Multi_DrawDebugLine_Implementation(
FVector LineStart,
FVector LineEnd,
FColor LineColor,
bool bPersistentLines,
float LifeTime,
char DepthPriority,
float Thickness) { NativeCall<
void,
FVector,
FVector,
FColor,
bool,
float,
char,
float>(
this,
"AActor.Multi_DrawDebugLine_Implementation", LineStart, LineEnd, LineColor, bPersistentLines, LifeTime, DepthPriority, Thickness); }
1201 void Multi_DrawDebugSphere_Implementation(
FVector Center,
float Radius,
int Segments,
FColor SphereColor,
bool bPersistentLines,
float LifeTime,
char DepthPriority) { NativeCall<
void,
FVector,
float,
int,
FColor,
bool,
float,
char>(
this,
"AActor.Multi_DrawDebugSphere_Implementation", Center, Radius, Segments, SphereColor, bPersistentLines, LifeTime, DepthPriority); }
1202 void MulticastProperty(
FName PropertyName,
bool bUnreliable) { NativeCall<
void,
FName,
bool>(
this,
"AActor.MulticastProperty", PropertyName, bUnreliable); }
1204 void NetActorSpawnActorUnreliable_Implementation(
TSubclassOf<
AActor> ActorClass,
FVector AtLoc,
FRotator AtRot,
bool bIgnoreOnDedicatedServer,
USceneComponent* AttachToComponent,
FName BoneName,
AActor* SpawnOwner) { NativeCall<
void,
TSubclassOf<
AActor>,
FVector,
FRotator,
bool,
USceneComponent*,
FName,
AActor*>(
this,
"AActor.NetActorSpawnActorUnreliable_Implementation", ActorClass, AtLoc, AtRot, bIgnoreOnDedicatedServer, AttachToComponent, BoneName, SpawnOwner); }
1205 void NetActorSpawnActor_Implementation(
TSubclassOf<
AActor> ActorClass,
FVector AtLoc,
FRotator AtRot,
bool bIgnoreOnDedicatedServer,
USceneComponent* AttachToComponent,
FName BoneName,
AActor* SpawnOwner) { NativeCall<
void,
TSubclassOf<
AActor>,
FVector,
FRotator,
bool,
USceneComponent*,
FName,
AActor*>(
this,
"AActor.NetActorSpawnActor_Implementation", ActorClass, AtLoc, AtRot, bIgnoreOnDedicatedServer, AttachToComponent, BoneName, SpawnOwner); }
1206 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); }
1208 void Net_DrawDebugBox(
FVector* Center,
FVector* BoxExtent, FQuat* Rotation,
FColor* BoxColor,
bool bPersistentLines,
float LifeTime,
char DepthPriority) { NativeCall<
void,
FVector*,
FVector*, FQuat*,
FColor*,
bool,
float,
char>(
this,
"AActor.Net_DrawDebugBox", Center, BoxExtent, Rotation, BoxColor, bPersistentLines, LifeTime, DepthPriority); }
1209 void Net_DrawDebugCapsule(
FVector* Center,
float HalfHeight,
float Radius, FQuat* Rotation,
FColor* CapsuleColor,
bool bPersistentLines,
float LifeTime,
char DepthPriority) { NativeCall<
void,
FVector*,
float,
float, FQuat*,
FColor*,
bool,
float,
char>(
this,
"AActor.Net_DrawDebugCapsule", Center, HalfHeight, Radius, Rotation, CapsuleColor, bPersistentLines, LifeTime, DepthPriority); }
1210 void Net_DrawDebugCoordinateSystem(
FVector* AxisLoc,
FRotator* AxisRot,
float Scale,
bool bPersistentLines,
float LifeTime,
char DepthPriority,
float Thickness) { NativeCall<
void,
FVector*,
FRotator*,
float,
bool,
float,
char,
float>(
this,
"AActor.Net_DrawDebugCoordinateSystem", AxisLoc, AxisRot, Scale, bPersistentLines, LifeTime, DepthPriority, Thickness); }
1211 void Net_DrawDebugDirectionalArrow(
FVector* LineStart,
FVector* LineEnd,
float ArrowSize,
FColor* ArrowColor,
bool bPersistentLines,
float LifeTime,
char DepthPriority) { NativeCall<
void,
FVector*,
FVector*,
float,
FColor*,
bool,
float,
char>(
this,
"AActor.Net_DrawDebugDirectionalArrow", LineStart, LineEnd, ArrowSize, ArrowColor, bPersistentLines, LifeTime, DepthPriority); }
1212 void Net_DrawDebugLine(
FVector* LineStart,
FVector* LineEnd,
FColor* LineColor,
bool bPersistentLines,
float LifeTime,
char DepthPriority,
float Thickness) { NativeCall<
void,
FVector*,
FVector*,
FColor*,
bool,
float,
char,
float>(
this,
"AActor.Net_DrawDebugLine", LineStart, LineEnd, LineColor, bPersistentLines, LifeTime, DepthPriority, Thickness); }
1213 void Net_DrawDebugSphere(
FVector* Center,
float Radius,
int Segments,
FColor* SphereColor,
bool bPersistentLines,
float LifeTime,
char DepthPriority) { NativeCall<
void,
FVector*,
float,
int,
FColor*,
bool,
float,
char>(
this,
"AActor.Net_DrawDebugSphere", Center, Radius, Segments, SphereColor, bPersistentLines, LifeTime, DepthPriority); }
1218 void PlaySoundAtLocation(USoundCue* InSoundCue,
FVector SoundLocation,
float VolumeMultiplier,
float PitchMultiplier) { NativeCall<
void, USoundCue*,
FVector,
float,
float>(
this,
"AActor.PlaySoundAtLocation", InSoundCue, SoundLocation, VolumeMultiplier, PitchMultiplier); }
1219 void PlaySoundOnActor(USoundCue* InSoundCue,
float VolumeMultiplier,
float PitchMultiplier) { NativeCall<
void, USoundCue*,
float,
float>(
this,
"AActor.PlaySoundOnActor", InSoundCue, VolumeMultiplier, PitchMultiplier); }
1223 void PostLoad() { NativeCall<
void>(
this,
"AActor.PostLoad"); }
1229 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); }
1232 void PrestreamTextures(
float Seconds,
bool bEnableStreaming,
int CinematicTextureGroups) { NativeCall<
void,
float,
bool,
int>(
this,
"AActor.PrestreamTextures", Seconds, bEnableStreaming, CinematicTextureGroups); }
1238 void RegisterActorTickFunctions(
bool bRegister,
bool bSaveAndRestoreTickState) { NativeCall<
void,
bool,
bool>(
this,
"AActor.RegisterActorTickFunctions", bRegister, bSaveAndRestoreTickState); }
1239 void RegisterAllActorTickFunctions(
bool bRegister,
bool bDoComponents,
bool bSaveAndRestoreTickState) { NativeCall<
void,
bool,
bool,
bool>(
this,
"AActor.RegisterAllActorTickFunctions", bRegister, bDoComponents, bSaveAndRestoreTickState); }
1245 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); }
1253 void ServerSendSimpleExecCommandToEveryone(
FName CommandName,
bool bIsReliable,
bool bForceSendToLocalPlayer,
bool bIgnoreRelevancy) { NativeCall<
void,
FName,
bool,
bool,
bool>(
this,
"AActor.ServerSendSimpleExecCommandToEveryone", CommandName, bIsReliable, bForceSendToLocalPlayer, bIgnoreRelevancy); }
1254 void SetActorEnableCollision(
bool bNewActorEnableCollision,
bool bCheckRecreatePhysicsState) { NativeCall<
void,
bool,
bool>(
this,
"AActor.SetActorEnableCollision", bNewActorEnableCollision, bCheckRecreatePhysicsState); }
1255 void SetActorHiddenInGame(
bool bNewHidden) { NativeCall<
void,
bool>(
this,
"AActor.SetActorHiddenInGame", bNewHidden); }
1262 bool SetActorRotation(FQuat* NewRotation) {
return NativeCall<
bool, FQuat*>(
this,
"AActor.SetActorRotation", NewRotation); }
1265 void SetActorTickEnabled(
bool bEnabled) { NativeCall<
void,
bool>(
this,
"AActor.SetActorTickEnabled", bEnabled); }
1267 void SetAutonomousProxy(
bool bInAutonomousProxy) { NativeCall<
void,
bool>(
this,
"AActor.SetAutonomousProxy", bInAutonomousProxy); }
1268 void SetLifeSpan(
float InLifespan) { NativeCall<
void,
float>(
this,
"AActor.SetLifeSpan", InLifespan); }
1269 void SetNetUpdateTime(
long double NewUpdateTime) { NativeCall<
void,
long double>(
this,
"AActor.SetNetUpdateTime", NewUpdateTime); }
1272 void SetReplicates(
bool bInReplicates) { NativeCall<
void,
bool>(
this,
"AActor.SetReplicates", bInReplicates); }
1274 void SetTickFunctionEnabled(
bool bEnableTick) { NativeCall<
void,
bool>(
this,
"AActor.SetTickFunctionEnabled", bEnableTick); }
1275 void SetTickableWhenPaused(
bool bTickableWhenPaused) { NativeCall<
void,
bool>(
this,
"AActor.SetTickableWhenPaused", bTickableWhenPaused); }
1278 void Stasis() { NativeCall<
void>(
this,
"AActor.Stasis"); }
1279 void StopActorSound(USoundBase* SoundAsset,
float FadeOutTime) { NativeCall<
void, USoundBase*,
float>(
this,
"AActor.StopActorSound", SoundAsset, FadeOutTime); }
1280 float TakeDamage(
float DamageAmount,
FDamageEvent* DamageEvent,
AController* EventInstigator,
AActor* DamageCauser) {
return NativeCall<
float,
float,
FDamageEvent*,
AController*,
AActor*>(
this,
"AActor.TakeDamage", DamageAmount, DamageEvent, EventInstigator, DamageCauser); }
1281 bool TeleportTo(
FVector* DestLocation,
FRotator* DestRotation,
bool bIsATest,
bool bNoCheck) {
return NativeCall<
bool,
FVector*,
FRotator*,
bool,
bool>(
this,
"AActor.TeleportTo", DestLocation, DestRotation, bIsATest, bNoCheck); }
1282 void Tick(
float DeltaSeconds) { NativeCall<
void,
float>(
this,
"AActor.Tick", DeltaSeconds); }
1285 void UnregisterAllComponents(
bool bDetachFromOtherParent) { NativeCall<
void,
bool>(
this,
"AActor.UnregisterAllComponents", bDetachFromOtherParent); }
1286 void Unstasis() { NativeCall<
void>(
this,
"AActor.Unstasis"); }
1287 void UpdateOverlaps(
bool bDoNotifies) { NativeCall<
void,
bool>(
this,
"AActor.UpdateOverlaps", bDoNotifies); }
1290 void ForceNetUpdate(
bool bDormantDontReplicateProperties,
bool bAbsoluteForceNetUpdate,
bool bDontUpdateChannel) { NativeCall<
void,
bool,
bool,
bool>(
this,
"AActor.ForceNetUpdate", bDormantDontReplicateProperties, bAbsoluteForceNetUpdate, bDontUpdateChannel); }
1291 void ForceReplicateNow(
bool bForceCreateChannel,
bool bForceCreateChannelIfRelevant) { NativeCall<
void,
bool,
bool>(
this,
"AActor.ForceReplicateNow", bForceCreateChannel, bForceCreateChannelIfRelevant); }
1292 void ActorPlaySound(USoundBase* SoundAsset,
bool bAttach,
FName BoneName,
FVector LocOffset) { NativeCall<
void, USoundBase*,
bool,
FName,
FVector>(
this,
"AActor.ActorPlaySound", SoundAsset, bAttach, BoneName, LocOffset); }
1293 void ActorPlaySoundUnreliable(USoundBase* SoundAsset,
bool bAttach,
FName BoneName,
FVector LocOffset) { NativeCall<
void, USoundBase*,
bool,
FName,
FVector>(
this,
"AActor.ActorPlaySoundUnreliable", SoundAsset, bAttach, BoneName, LocOffset); }
1301 bool BPConsumeSetPinCode(
APlayerController* ForPC,
int appledPinCode,
bool bIsSetting,
int TheCustomIndex) {
return NativeCall<
bool,
APlayerController*,
int,
bool,
int>(
this,
"AActor.BPConsumeSetPinCode", ForPC, appledPinCode, bIsSetting, TheCustomIndex); }
1302 bool BPConsumeUsePinCode(
AActor* FromKeypadActor,
APlayerController* ForPC,
int appledPinCode,
bool bIsActivating) {
return NativeCall<
bool,
AActor*,
APlayerController*,
int,
bool>(
this,
"AActor.BPConsumeUsePinCode", FromKeypadActor, ForPC, appledPinCode, bIsActivating); }
1317 FString*
GetEditTextString(
FString* result,
APlayerController* ForPC,
UObject* AssociatedObject1,
int ExtraID1,
int ExtraID2) {
return NativeCall<
FString*,
FString*,
APlayerController*,
UObject*,
int,
int>(
this,
"AActor.GetEditTextString", result, ForPC, AssociatedObject1, ExtraID1, ExtraID2); }
1324 void Multi_DrawDebugCoordinateSystem(
FVector AxisLoc,
FRotator AxisRot,
float Scale,
bool bPersistentLines,
float LifeTime,
char DepthPriority,
float Thickness) { NativeCall<
void,
FVector,
FRotator,
float,
bool,
float,
char,
float>(
this,
"AActor.Multi_DrawDebugCoordinateSystem", AxisLoc, AxisRot, Scale, bPersistentLines, LifeTime, DepthPriority, Thickness); }
1325 void Multi_DrawDebugDirectionalArrow(
FVector LineStart,
FVector LineEnd,
float ArrowSize,
FColor ArrowColor,
bool bPersistentLines,
float LifeTime,
char DepthPriority) { NativeCall<
void,
FVector,
FVector,
float,
FColor,
bool,
float,
char>(
this,
"AActor.Multi_DrawDebugDirectionalArrow", LineStart, LineEnd, ArrowSize, ArrowColor, bPersistentLines, LifeTime, DepthPriority); }
1326 void Multi_DrawDebugLine(
FVector LineStart,
FVector LineEnd,
FColor LineColor,
bool bPersistentLines,
float LifeTime,
char DepthPriority,
float Thickness) { NativeCall<
void,
FVector,
FVector,
FColor,
bool,
float,
char,
float>(
this,
"AActor.Multi_DrawDebugLine", LineStart, LineEnd, LineColor, bPersistentLines, LifeTime, DepthPriority, Thickness); }
1327 void Multi_DrawDebugSphere(
FVector Center,
float Radius,
int Segments,
FColor SphereColor,
bool bPersistentLines,
float LifeTime,
char DepthPriority) { NativeCall<
void,
FVector,
float,
int,
FColor,
bool,
float,
char>(
this,
"AActor.Multi_DrawDebugSphere", Center, Radius, Segments, SphereColor, bPersistentLines, LifeTime, DepthPriority); }
1328 void NetActorSpawnActor(
TSubclassOf<
AActor> ActorClass,
FVector AtLoc,
FRotator AtRot,
bool bIgnoreOnDedicatedServer,
USceneComponent* AttachToComponent,
FName BoneName,
AActor* SpawnOwner) { NativeCall<
void,
TSubclassOf<
AActor>,
FVector,
FRotator,
bool,
USceneComponent*,
FName,
AActor*>(
this,
"AActor.NetActorSpawnActor", ActorClass, AtLoc, AtRot, bIgnoreOnDedicatedServer, AttachToComponent, BoneName, SpawnOwner); }
1329 void NetAttachRootComponentTo(
USceneComponent* InParent,
FName InSocketName,
FVector RelativeLocation,
FRotator RelativeRotation) { NativeCall<
void,
USceneComponent*,
FName,
FVector,
FRotator>(
this,
"AActor.NetAttachRootComponentTo", InParent, InSocketName, RelativeLocation, RelativeRotation); }
1346 void ReceiveAnyDamage(
float Damage,
UDamageType* DamageType,
AController* InstigatedBy,
AActor* DamageCauser) { NativeCall<
void,
float,
UDamageType*,
AController*,
AActor*>(
this,
"AActor.ReceiveAnyDamage", Damage, DamageType, InstigatedBy, DamageCauser); }
1350 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); }
1351 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); }
1352 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); }
1353 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); }
1354 void ReceiveTick(
float DeltaSeconds) { NativeCall<
void,
float>(
this,
"AActor.ReceiveTick", DeltaSeconds); }
1400 void AddMovementInput(
FVector WorldDirection,
float ScaleValue,
bool bForce) { NativeCall<
void,
FVector,
float,
bool>(
this,
"APawn.AddMovementInput", WorldDirection, ScaleValue, bForce); }
1405 void Destroyed() { NativeCall<
void>(
this,
"APawn.Destroyed"); }
1409 void FaceRotation(
FRotator NewControlRotation,
float DeltaTime,
bool bFromController) { NativeCall<
void,
FRotator,
float,
bool>(
this,
"APawn.FaceRotation", NewControlRotation, DeltaTime, bFromController); }
1421 float GetNetPriority(
FVector* ViewPos,
FVector* ViewDir,
APlayerController* Viewer, UActorChannel* InChannel,
float Time,
bool bLowBandwidth) {
return NativeCall<
float,
FVector*,
FVector*,
APlayerController*, UActorChannel*,
float,
bool>(
this,
"APawn.GetNetPriority", ViewPos, ViewDir, Viewer, InChannel, Time, bLowBandwidth); }
1426 bool InFreeCam() {
return NativeCall<
bool>(
this,
"APawn.InFreeCam"); }
1430 bool IsControlled() {
return NativeCall<
bool>(
this,
"APawn.IsControlled"); }
1431 bool IsCrouched() {
return NativeCall<
bool>(
this,
"APawn.IsCrouched"); }
1432 bool IsFalling() {
return NativeCall<
bool>(
this,
"APawn.IsFalling"); }
1437 bool IsWalking() {
return NativeCall<
bool>(
this,
"APawn.IsWalking"); }
1439 void LaunchPawn(
FVector LaunchVelocity,
bool bXYOverride,
bool bZOverride) { NativeCall<
void,
FVector,
bool,
bool>(
this,
"APawn.LaunchPawn", LaunchVelocity, bXYOverride, bZOverride); }
1444 void PawnMakeNoise(
float Loudness,
FVector NoiseLocation,
bool bUseNoiseMakerLocation,
AActor* NoiseMaker) { NativeCall<
void,
float,
FVector,
bool,
AActor*>(
this,
"APawn.PawnMakeNoise", Loudness, NoiseLocation, bUseNoiseMakerLocation, NoiseMaker); }
1448 void PostLoad() { NativeCall<
void>(
this,
"APawn.PostLoad"); }
1455 void Reset() { NativeCall<
void>(
this,
"APawn.Reset"); }
1456 void Restart() { NativeCall<
void>(
this,
"APawn.Restart"); }
1458 bool ShouldTakeDamage(
float Damage,
FDamageEvent* DamageEvent,
AController* EventInstigator,
AActor* DamageCauser) {
return NativeCall<
bool,
float,
FDamageEvent*,
AController*,
AActor*>(
this,
"APawn.ShouldTakeDamage", Damage, DamageEvent, EventInstigator, DamageCauser); }
1461 float TakeDamage(
float Damage,
FDamageEvent* DamageEvent,
AController* EventInstigator,
AActor* DamageCauser) {
return NativeCall<
float,
float,
FDamageEvent*,
AController*,
AActor*>(
this,
"APawn.TakeDamage", Damage, DamageEvent, EventInstigator, DamageCauser); }
1462 void Tick(
float DeltaSeconds) { NativeCall<
void,
float>(
this,
"APawn.Tick", DeltaSeconds); }
1463 void TickBasedCharacters(
float DeltaSeconds) { NativeCall<
void,
float>(
this,
"APawn.TickBasedCharacters", DeltaSeconds); }
1464 void TurnOff() { NativeCall<
void>(
this,
"APawn.TurnOff"); }
1492 void BugIt(
FString* ScreenShotDescription) { NativeCall<
void,
FString*>(
this,
"UCheatManager.BugIt", ScreenShotDescription); }
1493 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); }
1495 void BugItStringCreator(
FVector ViewLocation,
FRotator ViewRotation,
FString* GoString,
FString* LocString) { NativeCall<
void,
FVector,
FRotator,
FString*,
FString*>(
this,
"UCheatManager.BugItStringCreator", ViewLocation, ViewRotation, GoString, LocString); }
1497 void ChangeSize(
float F) { NativeCall<
void,
float>(
this,
"UCheatManager.ChangeSize", F); }
1498 void DamageTarget(
float DamageAmount) { NativeCall<
void,
float>(
this,
"UCheatManager.DamageTarget", DamageAmount); }
1503 void DebugCapsuleSweepComplex(
bool bTraceComplex) { NativeCall<
void,
bool>(
this,
"UCheatManager.DebugCapsuleSweepComplex", bTraceComplex); }
1505 void DebugCapsuleSweepSize(
float HalfHeight,
float Radius) { NativeCall<
void,
float,
float>(
this,
"UCheatManager.DebugCapsuleSweepSize", HalfHeight, Radius); }
1513 void FlushLog() { NativeCall<
void>(
this,
"UCheatManager.FlushLog"); }
1514 void Fly() { NativeCall<
void>(
this,
"UCheatManager.Fly"); }
1515 void FreezeFrame(
float delay) { NativeCall<
void,
float>(
this,
"UCheatManager.FreezeFrame", delay); }
1517 void Ghost() { NativeCall<
void>(
this,
"UCheatManager.Ghost"); }
1518 void God() { NativeCall<
void>(
this,
"UCheatManager.God"); }
1519 void LogLoc() { NativeCall<
void>(
this,
"UCheatManager.LogLoc"); }
1521 void PlayersOnly() { NativeCall<
void>(
this,
"UCheatManager.PlayersOnly"); }
1523 void SetLevelStreamingStatus(
FName PackageName,
bool bShouldBeLoaded,
bool bShouldBeVisible) { NativeCall<
void,
FName,
bool,
bool>(
this,
"UCheatManager.SetLevelStreamingStatus", PackageName, bShouldBeLoaded, bShouldBeVisible); }
1524 void SetNavDrawDistance(
float DrawDistance) { NativeCall<
void,
float>(
this,
"UCheatManager.SetNavDrawDistance", DrawDistance); }
1526 void Slomo(
float T) { NativeCall<
void,
float>(
this,
"UCheatManager.Slomo", T); }
1530 void Teleport() { NativeCall<
void>(
this,
"UCheatManager.Teleport"); }
1536 void ViewSelf() { NativeCall<
void>(
this,
"UCheatManager.ViewSelf"); }
1537 void Walk() { NativeCall<
void>(
this,
"UCheatManager.Walk"); }
1551 void AddExperience(
float HowMuch,
bool fromTribeShare,
bool bPreventSharingWithTribe) { NativeCall<
void,
float,
bool,
bool>(
this,
"UShooterCheatManager.AddExperience", HowMuch, fromTribeShare, bPreventSharingWithTribe); }
1552 void AddShipExperience(
float HowMuch) { NativeCall<
void,
float>(
this,
"UShooterCheatManager.AddShipExperience", HowMuch); }
1555 void BritishEmpire() { NativeCall<
void>(
this,
"UShooterCheatManager.BritishEmpire"); }
1557 void CamZoomIn() { NativeCall<
void>(
this,
"UShooterCheatManager.CamZoomIn"); }
1558 void CamZoomOut() { NativeCall<
void>(
this,
"UShooterCheatManager.CamZoomOut"); }
1560 void ClearPlayerInventory(
int playerID,
bool bClearInventory,
bool bClearSlotItems,
bool bClearEquippedItems) { NativeCall<
void,
int,
bool,
bool,
bool>(
this,
"UShooterCheatManager.ClearPlayerInventory", playerID, bClearInventory, bClearSlotItems, bClearEquippedItems); }
1561 void ClearTutorials() { NativeCall<
void>(
this,
"UShooterCheatManager.ClearTutorials"); }
1564 void CompleteQuest(
int QuestID) { NativeCall<
void,
int>(
this,
"UShooterCheatManager.CompleteQuest", QuestID); }
1569 void DestroyAllTames() { NativeCall<
void>(
this,
"UShooterCheatManager.DestroyAllTames"); }
1570 void DestroyMyTarget() { NativeCall<
void>(
this,
"UShooterCheatManager.DestroyMyTarget"); }
1573 void DestroyTribeId(
int TribeTeamID) { NativeCall<
void,
int>(
this,
"UShooterCheatManager.DestroyTribeId", TribeTeamID); }
1574 void DestroyTribeIdDinos(
unsigned __int64 TribeTeamID) { NativeCall<
void,
unsigned __int64>(
this,
"UShooterCheatManager.DestroyTribeIdDinos", TribeTeamID); }
1575 void DestroyTribeIdPlayers(
__int64 TribeTeamID) { NativeCall<
void,
__int64>(
this,
"UShooterCheatManager.DestroyTribeIdPlayers", TribeTeamID); }
1576 void DestroyTribeIdStructures(
__int64 TribeTeamID) { NativeCall<
void,
__int64>(
this,
"UShooterCheatManager.DestroyTribeIdStructures", TribeTeamID); }
1579 void DestroyTribeStructuresLessThan(
int TribeTeamID,
int Connections) { NativeCall<
void,
int,
int>(
this,
"UShooterCheatManager.DestroyTribeStructuresLessThan", TribeTeamID, Connections); }
1581 void DetachChar() { NativeCall<
void>(
this,
"UShooterCheatManager.DetachChar"); }
1582 void DisableBeds(
bool bDisableBedsOnServer) { NativeCall<
void,
bool>(
this,
"UShooterCheatManager.DisableBeds", bDisableBedsOnServer); }
1585 void DoExit() { NativeCall<
void>(
this,
"UShooterCheatManager.DoExit"); }
1586 void DoLeaveTribe() { NativeCall<
void>(
this,
"UShooterCheatManager.DoLeaveTribe"); }
1587 void DoRestartLevel() { NativeCall<
void>(
this,
"UShooterCheatManager.DoRestartLevel"); }
1589 void DoTame() { NativeCall<
void>(
this,
"UShooterCheatManager.DoTame"); }
1591 void EnableSpectator() { NativeCall<
void>(
this,
"UShooterCheatManager.EnableSpectator"); }
1592 void EnemyInVisible(
bool Invisible) { NativeCall<
void,
bool>(
this,
"UShooterCheatManager.EnemyInVisible", Invisible); }
1597 void ForceTame() { NativeCall<
void>(
this,
"UShooterCheatManager.ForceTame"); }
1598 void ForceTravelAbort(
int nForceAbort) { NativeCall<
void,
int>(
this,
"UShooterCheatManager.ForceTravelAbort", nForceAbort); }
1600 void GCM() { NativeCall<
void>(
this,
"UShooterCheatManager.GCM"); }
1601 void GCMP(
__int64 PlayerID) { NativeCall<
void,
__int64>(
this,
"UShooterCheatManager.GCMP", PlayerID); }
1602 void GCMT() { NativeCall<
void>(
this,
"UShooterCheatManager.GCMT"); }
1603 void GFI(
FName* blueprintPath,
int quantityOverride,
float qualityOverride,
bool bForceBlueprint) { NativeCall<
void,
FName*,
int,
float,
bool>(
this,
"UShooterCheatManager.GFI", blueprintPath, quantityOverride, qualityOverride, bForceBlueprint); }
1604 void GMBuff() { NativeCall<
void>(
this,
"UShooterCheatManager.GMBuff"); }
1605 void GMSummon(
FString* ClassName,
int Level) { NativeCall<
void,
FString*,
int>(
this,
"UShooterCheatManager.GMSummon", ClassName, Level); }
1608 void GetChat() { NativeCall<
void>(
this,
"UShooterCheatManager.GetChat"); }
1609 void GetGameLog() { NativeCall<
void>(
this,
"UShooterCheatManager.GetGameLog"); }
1611 void GetPlayerIDForSteamID(
int SteamID) { NativeCall<
void,
int>(
this,
"UShooterCheatManager.GetPlayerIDForSteamID", SteamID); }
1612 void GetSteamIDForPlayerID(
int PlayerID) { NativeCall<
void,
int>(
this,
"UShooterCheatManager.GetSteamIDForPlayerID", PlayerID); }
1613 void GetTribeIdPlayerList(
int TribeID) { NativeCall<
void,
int>(
this,
"UShooterCheatManager.GetTribeIdPlayerList", TribeID); }
1617 void GiveCreativeModeToPlayer(
__int64 PlayerID) { NativeCall<
void,
__int64>(
this,
"UShooterCheatManager.GiveCreativeModeToPlayer", PlayerID); }
1619 void GiveEngrams() { NativeCall<
void>(
this,
"UShooterCheatManager.GiveEngrams"); }
1620 void GiveExpToPlayer(
__int64 PlayerID,
float HowMuch,
bool fromTribeShare,
bool bPreventSharingWithTribe) { NativeCall<
void,
__int64,
float,
bool,
bool>(
this,
"UShooterCheatManager.GiveExpToPlayer", PlayerID, HowMuch, fromTribeShare, bPreventSharingWithTribe); }
1621 void GiveFOW() { NativeCall<
void>(
this,
"UShooterCheatManager.GiveFOW"); }
1622 void GiveItem(
FString* blueprintPath,
int quantityOverride,
float qualityOverride,
bool bForceBlueprint) { NativeCall<
void,
FString*,
int,
float,
bool>(
this,
"UShooterCheatManager.GiveItem", blueprintPath, quantityOverride, qualityOverride, bForceBlueprint); }
1623 void GiveItemNum(
int masterIndexNum,
int quantityOverride,
float qualityOverride,
bool bForceBlueprint) { NativeCall<
void,
int,
int,
float,
bool>(
this,
"UShooterCheatManager.GiveItemNum", masterIndexNum, quantityOverride, qualityOverride, bForceBlueprint); }
1624 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); }
1625 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); }
1626 void GiveResources() { NativeCall<
void>(
this,
"UShooterCheatManager.GiveResources"); }
1627 void GiveToMe() { NativeCall<
void>(
this,
"UShooterCheatManager.GiveToMe"); }
1628 void GiveTreasureLoot(
float TreasureQuality) { NativeCall<
void,
float>(
this,
"UShooterCheatManager.GiveTreasureLoot", TreasureQuality); }
1629 void GiveTreasureMap(
float Quality) { NativeCall<
void,
float>(
this,
"UShooterCheatManager.GiveTreasureMap", Quality); }
1630 void GridTP(
FString ServerGrid,
float ServerLocalPosX,
float ServerLocalPosY,
float ServerLocalPosZ) { NativeCall<
void,
FString,
float,
float,
float>(
this,
"UShooterCheatManager.GridTP", ServerGrid, ServerLocalPosX, ServerLocalPosY, ServerLocalPosZ); }
1631 void GridTPManual(
unsigned __int16 GridX,
unsigned __int16 GridY,
float ServerLocalPosX,
float ServerLocalPosY,
float ServerLocalPosZ) { NativeCall<
void,
unsigned __int16,
unsigned __int16,
float,
float,
float>(
this,
"UShooterCheatManager.GridTPManual", GridX, GridY, ServerLocalPosX, ServerLocalPosY, ServerLocalPosZ); }
1632 void GridTravelToGlobalPos(
float ToGlobalPosX,
float ToGlobalPosY,
float ToGlobalPosZ) { NativeCall<
void,
float,
float,
float>(
this,
"UShooterCheatManager.GridTravelToGlobalPos", ToGlobalPosX, ToGlobalPosY, ToGlobalPosZ); }
1633 void GridTravelToLocalPos(
unsigned __int16 GridX,
unsigned __int16 GridY,
float ServerLocalPosX,
float ServerLocalPosY,
float ServerLocalPosZ) { NativeCall<
void,
unsigned __int16,
unsigned __int16,
float,
float,
float>(
this,
"UShooterCheatManager.GridTravelToLocalPos", GridX, GridY, ServerLocalPosX, ServerLocalPosY, ServerLocalPosZ); }
1635 void HiWarp(
FString* ClassName,
int Index) { NativeCall<
void,
FString*,
int>(
this,
"UShooterCheatManager.HiWarp", ClassName, Index); }
1637 void HideTutorial(
int TutorialInde) { NativeCall<
void,
int>(
this,
"UShooterCheatManager.HideTutorial", TutorialInde); }
1638 void InfiniteAmmo() { NativeCall<
void>(
this,
"UShooterCheatManager.InfiniteAmmo"); }
1639 void InfiniteStats() { NativeCall<
void>(
this,
"UShooterCheatManager.InfiniteStats"); }
1641 void Kill() { NativeCall<
void>(
this,
"UShooterCheatManager.Kill"); }
1642 void KillPlayer(
__int64 PlayerID) { NativeCall<
void,
__int64>(
this,
"UShooterCheatManager.KillPlayer", PlayerID); }
1643 void LMA() { NativeCall<
void>(
this,
"UShooterCheatManager.LMA"); }
1644 void ListPlayers() { NativeCall<
void>(
this,
"UShooterCheatManager.ListPlayers"); }
1645 void MakeSpooky(
FString* ItemsToGive,
float SpawnDist,
int NumberOfSkeletons) { NativeCall<
void,
FString*,
float,
int>(
this,
"UShooterCheatManager.MakeSpooky", ItemsToGive, SpawnDist, NumberOfSkeletons); }
1646 void MakeTribeAdmin() { NativeCall<
void>(
this,
"UShooterCheatManager.MakeTribeAdmin"); }
1650 void OutGoingTransfersEnabled(
bool bEnabled) { NativeCall<
void,
bool>(
this,
"UShooterCheatManager.OutGoingTransfersEnabled", bEnabled); }
1655 void ReloadAdminIPs() { NativeCall<
void>(
this,
"UShooterCheatManager.ReloadAdminIPs"); }
1657 void ReloadTopTribes() { NativeCall<
void>(
this,
"UShooterCheatManager.ReloadTopTribes"); }
1664 void RotateTribeLog() { NativeCall<
void>(
this,
"UShooterCheatManager.RotateTribeLog"); }
1666 void SDF(
FName* DinoBlueprintPath,
bool bIsTamed) { NativeCall<
void,
FName*,
bool>(
this,
"UShooterCheatManager.SDF", DinoBlueprintPath, bIsTamed); }
1667 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); }
1668 void SSF(
FString* ShipName) { NativeCall<
void,
FString*>(
this,
"UShooterCheatManager.SSF", ShipName); }
1669 void SaveWorld() { NativeCall<
void>(
this,
"UShooterCheatManager.SaveWorld"); }
1675 void SetAdminFastClaiming(
bool bEnable) { NativeCall<
void,
bool>(
this,
"UShooterCheatManager.SetAdminFastClaiming", bEnable); }
1676 void SetAimMagnetism(
float NewMagnetism) { NativeCall<
void,
float>(
this,
"UShooterCheatManager.SetAimMagnetism", NewMagnetism); }
1677 void SetBabyAge(
float AgeValue) { NativeCall<
void,
float>(
this,
"UShooterCheatManager.SetBabyAge", AgeValue); }
1678 void SetBodyFat(
float BodyFatPercent) { NativeCall<
void,
float>(
this,
"UShooterCheatManager.SetBodyFat", BodyFatPercent); }
1679 void SetCheatXP(
bool bEnable) { NativeCall<
void,
bool>(
this,
"UShooterCheatManager.SetCheatXP", bEnable); }
1681 void SetDebugMelee(
bool Discrete,
int DebugMelee) { NativeCall<
void,
bool,
int>(
this,
"UShooterCheatManager.SetDebugMelee", Discrete, DebugMelee); }
1682 void SetFacialHairPercent(
float thePercent) { NativeCall<
void,
float>(
this,
"UShooterCheatManager.SetFacialHairPercent", thePercent); }
1683 void SetFacialHairstyle(
int hairStyleIndex) { NativeCall<
void,
int>(
this,
"UShooterCheatManager.SetFacialHairstyle", hairStyleIndex); }
1684 void SetGlobalPause(
bool bIsPaused) { NativeCall<
void,
bool>(
this,
"UShooterCheatManager.SetGlobalPause", bIsPaused); }
1685 void SetGodMode(
bool bEnable) { NativeCall<
void,
bool>(
this,
"UShooterCheatManager.SetGodMode", bEnable); }
1686 void SetGraphicsQuality(
int val) { NativeCall<
void,
int>(
this,
"UShooterCheatManager.SetGraphicsQuality", val); }
1687 void SetHeadHairPercent(
float thePercent) { NativeCall<
void,
float>(
this,
"UShooterCheatManager.SetHeadHairPercent", thePercent); }
1688 void SetHeadHairstyle(
int hairStyleIndex) { NativeCall<
void,
int>(
this,
"UShooterCheatManager.SetHeadHairstyle", hairStyleIndex); }
1689 void SetHomeServer(
int PlayerID,
unsigned int ServerID) { NativeCall<
void,
int,
unsigned int>(
this,
"UShooterCheatManager.SetHomeServer", PlayerID, ServerID); }
1690 void SetIgnoreWind(
bool ShouldIgnore) { NativeCall<
void,
bool>(
this,
"UShooterCheatManager.SetIgnoreWind", ShouldIgnore); }
1691 void SetImprintQuality(
float ImprintQuality) { NativeCall<
void,
float>(
this,
"UShooterCheatManager.SetImprintQuality", ImprintQuality); }
1692 void SetInterpolatedLocation(
bool NewValue) { NativeCall<
void,
bool>(
this,
"UShooterCheatManager.SetInterpolatedLocation", NewValue); }
1694 void SetMyTargetSleeping(
bool bIsSleeping) { NativeCall<
void,
bool>(
this,
"UShooterCheatManager.SetMyTargetSleeping", bIsSleeping); }
1695 void SetMyTribeAllowRename(
bool bAllow) { NativeCall<
void,
bool>(
this,
"UShooterCheatManager.SetMyTribeAllowRename", bAllow); }