class

InteractiveDevice

10 properties
54 functions
53 derived classes

Extends Device game.DeviceBase game.Object ent.GameEntity ent.Entity IScriptable ISerializable

Properties

Property	Type	Offset
`interaction`	`game.interactions.Component?`	`0x350`	scripted
`interactionIndicator`	`game.LightComponent?`	`0x360`	scripted
`disableAreaIndicatorID`	`game.DelayID`	`0x370`	scripted
`delayedUIRefreshID`	`game.DelayID`	`0x378`	scripted
`isPlayerAround`	`bool`	`0x380`	scripted
`disableAreaIndicatorDelayActive`	`bool`	`0x381`	scripted
`objectActionsCallbackCtrl`	`game.ObjectActionsCallbackController?`	`0x388`	scripted
`investigationData`	`InvestigationData[]`	`0x398`	scripted
`actionRestrictionPlayerBB`	`WeakHandle<game.IBlackboard>`	`0x3A8`	scripted
`actionRestrictionCallbackID`	`red.CallbackObject?`	`0x3B8`	scripted

Functions

bool OnRequestComponents(ent.EntityRequestComponentsInterface ri) overrideRTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "OnRequestComponents",
    (InteractiveDevice_OnRequestComponents x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_OnRequestComponents(
    InteractiveDevice self,
    ent.EntityRequestComponentsInterface ri
);

bool OnTakeControl(ent.EntityResolveComponentsInterface ri) overrideRTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "OnTakeControl",
    (InteractiveDevice_OnTakeControl x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_OnTakeControl(
    InteractiveDevice self,
    ent.EntityResolveComponentsInterface ri
);

bool OnDetach() overrideRTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "OnDetach",
    (InteractiveDevice_OnDetach x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_OnDetach(
    InteractiveDevice self
);

void ToggleDirectLayer(bool input) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "ToggleDirectLayer;Bool",
    (InteractiveDevice_ToggleDirectLayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_ToggleDirectLayer(
    InteractiveDevice self,
    bool input
);

void ToggleLogicLayer(bool input) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "ToggleLogicLayer;Bool",
    (InteractiveDevice_ToggleLogicLayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_ToggleLogicLayer(
    InteractiveDevice self,
    bool input
);

void DeactivateDevice() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "DeactivateDevice;",
    (InteractiveDevice_DeactivateDevice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_DeactivateDevice(
    InteractiveDevice self
);

void ActivateDevice() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "ActivateDevice;",
    (InteractiveDevice_ActivateDevice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_ActivateDevice(
    InteractiveDevice self
);

void CutPower() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "CutPower;",
    (InteractiveDevice_CutPower x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_CutPower(
    InteractiveDevice self
);

void TurnOnDevice() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "TurnOnDevice;",
    (InteractiveDevice_TurnOnDevice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_TurnOnDevice(
    InteractiveDevice self
);

void TurnOffDevice() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "TurnOffDevice;",
    (InteractiveDevice_TurnOffDevice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_TurnOffDevice(
    InteractiveDevice self
);

bool UpdateDeviceState(bool? isDelayed) overrideRTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "UpdateDeviceState;Bool",
    (InteractiveDevice_UpdateDeviceState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_UpdateDeviceState(
    InteractiveDevice self,
    bool? isDelayed
);

void TurnOnIndicator() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "TurnOnIndicator;",
    (InteractiveDevice_TurnOnIndicator x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_TurnOnIndicator(
    InteractiveDevice self
);

void TurnOffIndicator() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "TurnOffIndicator;",
    (InteractiveDevice_TurnOffIndicator x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_TurnOffIndicator(
    InteractiveDevice self
);

bool IsPlayerAround() overrideRTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "IsPlayerAround;",
    (InteractiveDevice_IsPlayerAround x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_IsPlayerAround(
    InteractiveDevice self
);

bool OnInteractionActivated(game.interactions.InteractionActivationEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "OnInteractionActivated",
    (InteractiveDevice_OnInteractionActivated x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_OnInteractionActivated(
    InteractiveDevice self,
    game.interactions.InteractionActivationEvent? evt
);

void OnVisibilityChanged() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "OnVisibilityChanged;",
    (InteractiveDevice_OnVisibilityChanged x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_OnVisibilityChanged(
    InteractiveDevice self
);

bool OnLogicReady(SetLogicReadyEvent evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "OnLogicReady",
    (InteractiveDevice_OnLogicReady x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_OnLogicReady(
    InteractiveDevice self,
    SetLogicReadyEvent? evt
);

Vector4[] GetCachedInvestigationPositionsArray(world.GlobalNodeRef globalNodeRef) overrideRTTI

int GetInvestigationDataIndexFor(world.GlobalNodeRef globalNodeRef) RTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "GetInvestigationDataIndexFor;GlobalNodeRef",
    (InteractiveDevice_GetInvestigationDataIndexFor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_GetInvestigationDataIndexFor(
    InteractiveDevice self,
    world.GlobalNodeRef globalNodeRef
);

void SetInvestigationPositionsArray(world.GlobalNodeRef globalNodeRef, Vector4[] arr) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "SetInvestigationPositionsArray;GlobalNodeRefscript_ref<array<Vector4>>",
    (InteractiveDevice_SetInvestigationPositionsArray x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_SetInvestigationPositionsArray(
    InteractiveDevice self,
    world.GlobalNodeRef globalNodeRef,
    List<Vector4> arr
);

bool HasInvestigationPositionsArrayCached(world.GlobalNodeRef globalNodeRef) overrideRTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "HasInvestigationPositionsArrayCached;GlobalNodeRef",
    (InteractiveDevice_HasInvestigationPositionsArrayCached x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_HasInvestigationPositionsArrayCached(
    InteractiveDevice self,
    world.GlobalNodeRef globalNodeRef
);

void SetIsDoorInteractionActiveBB(game.interactions.InteractionActivationEvent evt, bool isActive) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "SetIsDoorInteractionActiveBB;InteractionActivationEventBool",
    (InteractiveDevice_SetIsDoorInteractionActiveBB x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_SetIsDoorInteractionActiveBB(
    InteractiveDevice self,
    game.interactions.InteractionActivationEvent? evt,
    bool isActive
);

void OnDirectInteractionActive(game.interactions.InteractionActivationEvent evt, bool isInteractionActive) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "OnDirectInteractionActive;InteractionActivationEventBool",
    (InteractiveDevice_OnDirectInteractionActive x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_OnDirectInteractionActive(
    InteractiveDevice self,
    game.interactions.InteractionActivationEvent? evt,
    bool isInteractionActive
);

game.IBlackboard? GetPlayerStateMachineBB(game.Object requester) RTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "GetPlayerStateMachineBB;GameObject",
    (InteractiveDevice_GetPlayerStateMachineBB x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IBlackboard>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_GetPlayerStateMachineBB(
    InteractiveDevice self,
    game.Object? requester
);

bool OnInteractionUsed(game.interactions.ChoiceEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "OnInteractionUsed",
    (InteractiveDevice_OnInteractionUsed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_OnInteractionUsed(
    InteractiveDevice self,
    game.interactions.ChoiceEvent? evt
);

bool OnPerformedAction(PerformedAction evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "OnPerformedAction",
    (InteractiveDevice_OnPerformedAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_OnPerformedAction(
    InteractiveDevice self,
    PerformedAction? evt
);

void RefreshInteraction(game.device.RequestType requestType, WeakHandle<game.Object> executor) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "RefreshInteraction;gamedeviceRequestTypeGameObject",
    (InteractiveDevice_RefreshInteraction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_RefreshInteraction(
    InteractiveDevice self,
    game.device.RequestType requestType,
    WeakHandle<game.Object> executor
);

void RefreshInteractionTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "RefreshInteractionTask;ScriptTaskData",
    (InteractiveDevice_RefreshInteractionTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_RefreshInteractionTask(
    InteractiveDevice self,
    game.ScriptTaskData? data
);

void EstimateIfPlayerEntersOrLeaves(game.interactions.InteractionActivationEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "EstimateIfPlayerEntersOrLeaves;InteractionActivationEvent",
    (InteractiveDevice_EstimateIfPlayerEntersOrLeaves x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_EstimateIfPlayerEntersOrLeaves(
    InteractiveDevice self,
    game.interactions.InteractionActivationEvent? evt
);

bool OnAction(game.input.ScriptListenerAction action, game.input.ScriptListenerActionConsumer consumer) RTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "OnAction",
    (InteractiveDevice_OnAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_OnAction(
    InteractiveDevice self,
    game.input.ScriptListenerAction action,
    game.input.ScriptListenerActionConsumer consumer
);

bool OnUIRefreshedEvent(UIRefreshedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "OnUIRefreshedEvent",
    (InteractiveDevice_OnUIRefreshedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_OnUIRefreshedEvent(
    InteractiveDevice self,
    UIRefreshedEvent? evt
);

bool OnUIUnstreamedEvent(UIUnstreamedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "OnUIUnstreamedEvent",
    (InteractiveDevice_OnUIUnstreamedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_OnUIUnstreamedEvent(
    InteractiveDevice self,
    UIUnstreamedEvent? evt
);

void RefreshUI(bool? isDelayed) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "RefreshUI;Bool",
    (InteractiveDevice_RefreshUI x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_RefreshUI(
    InteractiveDevice self,
    bool? isDelayed
);

bool OnForceUIRefreshEvent(ForceUIRefreshEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "OnForceUIRefreshEvent",
    (InteractiveDevice_OnForceUIRefreshEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_OnForceUIRefreshEvent(
    InteractiveDevice self,
    ForceUIRefreshEvent? evt
);

bool OnDelayedUIRefreshEvent(DelayedUIRefreshEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "OnDelayedUIRefreshEvent",
    (InteractiveDevice_OnDelayedUIRefreshEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_OnDelayedUIRefreshEvent(
    InteractiveDevice self,
    DelayedUIRefreshEvent? evt
);

bool IsReadyForUI() overrideRTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "IsReadyForUI;",
    (InteractiveDevice_IsReadyForUI x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_IsReadyForUI(
    InteractiveDevice self
);

void DetermineInteractionState(game.GetActionsContext? context) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "DetermineInteractionState;GetActionsContext",
    (InteractiveDevice_DetermineInteractionState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_DetermineInteractionState(
    InteractiveDevice self,
    game.GetActionsContext? context
);

void ResetChoicesByEvent() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "ResetChoicesByEvent;",
    (InteractiveDevice_ResetChoicesByEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_ResetChoicesByEvent(
    InteractiveDevice self
);

bool OnToggleUIInteractivity(ToggleUIInteractivity evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "OnToggleUIInteractivity",
    (InteractiveDevice_OnToggleUIInteractivity x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_OnToggleUIInteractivity(
    InteractiveDevice self,
    ToggleUIInteractivity? evt
);

void StartUsing() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "StartUsing;",
    (InteractiveDevice_StartUsing x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_StartUsing(
    InteractiveDevice self
);

void StopUsing() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "StopUsing;",
    (InteractiveDevice_StopUsing x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_StopUsing(
    InteractiveDevice self
);

void RequestDebuggerRegistration(ScriptedPuppet activator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "RequestDebuggerRegistration;ScriptedPuppet",
    (InteractiveDevice_RequestDebuggerRegistration x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_RequestDebuggerRegistration(
    InteractiveDevice self,
    ScriptedPuppet? activator
);

void UpdateDebugInfo() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "UpdateDebugInfo;",
    (InteractiveDevice_UpdateDebugInfo x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_UpdateDebugInfo(
    InteractiveDevice self
);

void PrintWorldSpaceDebug() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "PrintWorldSpaceDebug;",
    (InteractiveDevice_PrintWorldSpaceDebug x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_PrintWorldSpaceDebug(
    InteractiveDevice self
);

Vector4 GetNetworkBeamEndpoint() overrideRTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "GetNetworkBeamEndpoint;",
    (InteractiveDevice_GetNetworkBeamEndpoint x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_GetNetworkBeamEndpoint(
    InteractiveDevice self
);

bool HasAnyDirectInteractionActive() overrideRTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "HasAnyDirectInteractionActive;",
    (InteractiveDevice_HasAnyDirectInteractionActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_HasAnyDirectInteractionActive(
    InteractiveDevice self
);

bool OnEMPHitEvent(EMPHitEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "OnEMPHitEvent",
    (InteractiveDevice_OnEMPHitEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_OnEMPHitEvent(
    InteractiveDevice self,
    EMPHitEvent? evt
);

bool OnEMPEnded(EMPEnded evt) RTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "OnEMPEnded",
    (InteractiveDevice_OnEMPEnded x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_OnEMPEnded(
    InteractiveDevice self,
    EMPEnded? evt
);

bool OnSetUICameraZoomEvent(SetUICameraZoomEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "OnSetUICameraZoomEvent",
    (InteractiveDevice_OnSetUICameraZoomEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_OnSetUICameraZoomEvent(
    InteractiveDevice self,
    SetUICameraZoomEvent? evt
);

void CreateObjectActionsCallbackController(WeakHandle<ent.Entity> instigator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "CreateObjectActionsCallbackController;Entity",
    (InteractiveDevice_CreateObjectActionsCallbackController x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_CreateObjectActionsCallbackController(
    InteractiveDevice self,
    WeakHandle<ent.Entity> instigator
);

void DestroyObjectActionsCallbackController() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "DestroyObjectActionsCallbackController;",
    (InteractiveDevice_DestroyObjectActionsCallbackController x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_DestroyObjectActionsCallbackController(
    InteractiveDevice self
);

bool OnObjectActionRefreshEvent(game.ObjectActionRefreshEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "InteractiveDevice",
    "OnObjectActionRefreshEvent",
    (InteractiveDevice_OnObjectActionRefreshEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_OnObjectActionRefreshEvent(
    InteractiveDevice self,
    game.ObjectActionRefreshEvent? evt
);

void RegisterActionRestrictionCallback() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "RegisterActionRestrictionCallback;",
    (InteractiveDevice_RegisterActionRestrictionCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_RegisterActionRestrictionCallback(
    InteractiveDevice self
);

void UnregisterActionRestrictionCallback() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "InteractiveDevice",
    "UnregisterActionRestrictionCallback;",
    (InteractiveDevice_UnregisterActionRestrictionCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct InteractiveDevice_UnregisterActionRestrictionCallback(
    InteractiveDevice self
);