class

SharedGameplayPS

9 properties
25 functions
2 derived classes

Extends game.DeviceComponentPS game.ComponentPS game.PersistentState IScriptable ISerializable

Derived

DeviceLinkComponentPS, ScriptableDeviceComponentPS

Properties

Property	Type	Offset
`deviceState`	`EDeviceStatus`	`0x60`	scripted
`authorizationProperties`	`AuthorizationData`	`0x68`	scripted
`wasStateCached`	`bool`	`0x88`	scripted
`wasStateSet`	`bool`	`0x89`	scripted
`cachedDeviceState`	`EDeviceStatus`	`0x8A`	scripted
`revealDevicesGrid`	`bool`	`0x8E`	scripted
`revealDevicesGridWhenUnpowered`	`bool`	`0x8F`	scripted
`wasRevealedInNetworkPing`	`bool`	`0x90`	scripted
`hasNetworkBackdoor`	`bool`	`0x91`	scripted

Functions

EDeviceStatus GetDeviceState() RTTI

Generated hook

re.Hooks.Place(
    "SharedGameplayPS",
    "GetDeviceState;",
    (SharedGameplayPS_GetDeviceState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EDeviceStatus>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_GetDeviceState(
    SharedGameplayPS self
);

void CacheDeviceState(EDeviceStatus state) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SharedGameplayPS",
    "CacheDeviceState;EDeviceStatus",
    (SharedGameplayPS_CacheDeviceState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_CacheDeviceState(
    SharedGameplayPS self,
    EDeviceStatus state
);

void SetDeviceState(EDeviceStatus state) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SharedGameplayPS",
    "SetDeviceState;EDeviceStatus",
    (SharedGameplayPS_SetDeviceState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_SetDeviceState(
    SharedGameplayPS self,
    EDeviceStatus state
);

void EvaluateDeviceState() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SharedGameplayPS",
    "EvaluateDeviceState;",
    (SharedGameplayPS_EvaluateDeviceState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_EvaluateDeviceState(
    SharedGameplayPS self
);

void QueuePSEvent(WeakHandle<game.PersistentState> targetPS, red.Event evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SharedGameplayPS",
    "QueuePSEvent;PersistentStateEvent",
    (SharedGameplayPS_QueuePSEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_QueuePSEvent(
    SharedGameplayPS self,
    WeakHandle<game.PersistentState> targetPS,
    red.Event? evt
);

void QueuePSEvent(game.PersistentID targetID, CName psClassName, red.Event evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SharedGameplayPS",
    "QueuePSEvent;PersistentIDCNameEvent",
    (SharedGameplayPS_QueuePSEvent2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_QueuePSEvent2(
    SharedGameplayPS self,
    game.PersistentID targetID,
    CName psClassName,
    red.Event? evt
);

void QueuePSEventWithDelay(WeakHandle<game.PersistentState> targetPS, red.Event evt, float delay) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SharedGameplayPS",
    "QueuePSEventWithDelay;PersistentStateEventFloat",
    (SharedGameplayPS_QueuePSEventWithDelay x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_QueuePSEventWithDelay(
    SharedGameplayPS self,
    WeakHandle<game.PersistentState> targetPS,
    red.Event? evt,
    float delay
);

void QueuePSEventWithDelay(game.PersistentID targetID, CName psClassName, red.Event evt, float delay) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SharedGameplayPS",
    "QueuePSEventWithDelay;PersistentIDCNameEventFloat",
    (SharedGameplayPS_QueuePSEventWithDelay2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_QueuePSEventWithDelay2(
    SharedGameplayPS self,
    game.PersistentID targetID,
    CName psClassName,
    red.Event? evt,
    float delay
);

void QueueEntityEvent(ent.EntityID entityID, red.Event evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SharedGameplayPS",
    "QueueEntityEvent;EntityIDEvent",
    (SharedGameplayPS_QueueEntityEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_QueueEntityEvent(
    SharedGameplayPS self,
    ent.EntityID entityID,
    red.Event? evt
);

bool IsPartOfSystem(ESystems systemType) RTTI

Generated hook

re.Hooks.Place(
    "SharedGameplayPS",
    "IsPartOfSystem;ESystems",
    (SharedGameplayPS_IsPartOfSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_IsPartOfSystem(
    SharedGameplayPS self,
    ESystems systemType
);

bool IsConnectedToSecuritySystem() RTTI

Generated hook

re.Hooks.Place(
    "SharedGameplayPS",
    "IsConnectedToSecuritySystem;",
    (SharedGameplayPS_IsConnectedToSecuritySystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_IsConnectedToSecuritySystem(
    SharedGameplayPS self
);

bool IsConnectedToSecuritySystem(out ESecurityAccessLevel level) RTTI

Generated hook

re.Hooks.Place(
    "SharedGameplayPS",
    "IsConnectedToSecuritySystem;ESecurityAccessLevel",
    (SharedGameplayPS_IsConnectedToSecuritySystem2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_IsConnectedToSecuritySystem2(
    SharedGameplayPS self,
    ESecurityAccessLevel level
);

ESecurityAccessLevel GetSecurityAccessLevel() RTTI

Generated hook

re.Hooks.Place(
    "SharedGameplayPS",
    "GetSecurityAccessLevel;",
    (SharedGameplayPS_GetSecurityAccessLevel x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ESecurityAccessLevel>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_GetSecurityAccessLevel(
    SharedGameplayPS self
);

ESecurityAccessLevel FindHighestSecurityAccessLevel(SecurityAreaControllerPS[] securityAreas) RTTI

Generated hook

re.Hooks.Place(
    "SharedGameplayPS",
    "FindHighestSecurityAccessLevel;script_ref<array<SecurityAreaControllerPS>>",
    (SharedGameplayPS_FindHighestSecurityAccessLevel x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ESecurityAccessLevel>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_FindHighestSecurityAccessLevel(
    SharedGameplayPS self,
    SecurityAreaControllerPS[] securityAreas
);

bool IsBreached() RTTI

Generated hook

re.Hooks.Place(
    "SharedGameplayPS",
    "IsBreached;",
    (SharedGameplayPS_IsBreached x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_IsBreached(
    SharedGameplayPS self
);

bool HasNetworkBackdoor() RTTI

Generated hook

re.Hooks.Place(
    "SharedGameplayPS",
    "HasNetworkBackdoor;",
    (SharedGameplayPS_HasNetworkBackdoor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_HasNetworkBackdoor(
    SharedGameplayPS self
);

bool IsConnectedToBackdoorDevice() RTTI

Generated hook

re.Hooks.Place(
    "SharedGameplayPS",
    "IsConnectedToBackdoorDevice;",
    (SharedGameplayPS_IsConnectedToBackdoorDevice x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_IsConnectedToBackdoorDevice(
    SharedGameplayPS self
);

AccessPointControllerPS? GetBackdoorAccessPoint() RTTI

Generated hook

re.Hooks.Place(
    "SharedGameplayPS",
    "GetBackdoorAccessPoint;",
    (SharedGameplayPS_GetBackdoorAccessPoint x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.AccessPointControllerPS>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_GetBackdoorAccessPoint(
    SharedGameplayPS self
);

AccessPointControllerPS?[] GetAccessPoints() RTTI

string GetNetworkName() RTTI

Generated hook

re.Hooks.Place(
    "SharedGameplayPS",
    "GetNetworkName;",
    (SharedGameplayPS_GetNetworkName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_GetNetworkName(
    SharedGameplayPS self
);

ConnectedClassTypes CheckMasterConnectedClassTypes() RTTI

Generated hook

re.Hooks.Place(
    "SharedGameplayPS",
    "CheckMasterConnectedClassTypes;",
    (SharedGameplayPS_CheckMasterConnectedClassTypes x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ConnectedClassTypes>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_CheckMasterConnectedClassTypes(
    SharedGameplayPS self
);

bool WasRevealedInNetworkPing() RTTI

Generated hook

re.Hooks.Place(
    "SharedGameplayPS",
    "WasRevealedInNetworkPing;",
    (SharedGameplayPS_WasRevealedInNetworkPing x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_WasRevealedInNetworkPing(
    SharedGameplayPS self
);

void SetRevealedInNetworkPing(bool wasRevealed) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SharedGameplayPS",
    "SetRevealedInNetworkPing;Bool",
    (SharedGameplayPS_SetRevealedInNetworkPing x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_SetRevealedInNetworkPing(
    SharedGameplayPS self,
    bool wasRevealed
);

EntityNotificationType OnSetRevealedInNetwork(SetRevealedInNetwork evt) RTTI

Generated hook

re.Hooks.Place(
    "SharedGameplayPS",
    "OnSetRevealedInNetwork;SetRevealedInNetwork",
    (SharedGameplayPS_OnSetRevealedInNetwork x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_OnSetRevealedInNetwork(
    SharedGameplayPS self,
    SetRevealedInNetwork? evt
);

bool IsPuppet() RTTI

Generated hook

re.Hooks.Place(
    "SharedGameplayPS",
    "IsPuppet;",
    (SharedGameplayPS_IsPuppet x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SharedGameplayPS_IsPuppet(
    SharedGameplayPS self
);