class

DeviceOperations

2 properties
30 functions
9 derived classes

Derived

BaseActionOperations, BaseStateOperations, CustomActionOperations, DoorStateOperations, FocusModeOperations, HitOperations, InteractionAreaOperations, SensesOperations, TriggerVolumeOperations

Properties

Property	Type	Offset
`components`	`WeakHandle<ent.IPlacedComponent>[]`	`0x0`	scripted
`fxInstances`	`SVfxInstanceData[]`	`0x10`	scripted

Functions

void RequestComponents(ent.EntityRequestComponentsInterface ri) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "RequestComponents;EntityRequestComponentsInterface",
    (DeviceOperations_RequestComponents x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void TakeControl(ent.EntityResolveComponentsInterface ri) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "TakeControl;EntityResolveComponentsInterface",
    (DeviceOperations_TakeControl x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void ToggleOperation(bool enable, int index) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "ToggleOperation;BoolInt32",
    (DeviceOperations_ToggleOperation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_ToggleOperation(
    DeviceOperations self,
    bool enable,
    int index
);

bool IsOperationEnabled(int index) RTTI

Generated hook

re.Hooks.Place(
    "DeviceOperations",
    "IsOperationEnabled;Int32",
    (DeviceOperations_IsOperationEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_IsOperationEnabled(
    DeviceOperations self,
    int index
);

void SetDelayIdOnOperation(game.DelayID delayId, int operationID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "SetDelayIdOnOperation;DelayIDInt32",
    (DeviceOperations_SetDelayIdOnOperation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_SetDelayIdOnOperation(
    DeviceOperations self,
    game.DelayID delayId,
    int operationID
);

void ClearDelayIdOnOperation(int operationID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "ClearDelayIdOnOperation;Int32",
    (DeviceOperations_ClearDelayIdOnOperation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_ClearDelayIdOnOperation(
    DeviceOperations self,
    int operationID
);

void SendToggleOperataionEvent(bool enable, int index, EOperationClassType type, WeakHandle<game.Object> owner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "SendToggleOperataionEvent;BoolInt32EOperationClassTypeGameObject",
    (DeviceOperations_SendToggleOperataionEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_SendToggleOperataionEvent(
    DeviceOperations self,
    bool enable,
    int index,
    EOperationClassType type,
    WeakHandle<game.Object> owner
);

void DelayOperation(SBaseDeviceOperationData operation, WeakHandle<game.Object> owner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "DelayOperation;script_ref<SBaseDeviceOperationData>GameObject",
    (DeviceOperations_DelayOperation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_DelayOperation(
    DeviceOperations self,
    SBaseDeviceOperationData operation,
    WeakHandle<game.Object> owner
);

void Execute(SBaseDeviceOperationData operation, WeakHandle<game.Object> owner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "Execute;script_ref<SBaseDeviceOperationData>GameObject",
    (DeviceOperations_Execute x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_Execute(
    DeviceOperations self,
    SBaseDeviceOperationData operation,
    WeakHandle<game.Object> owner
);

void Restore(SBaseDeviceOperationData operation, WeakHandle<game.Object> owner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "Restore;script_ref<SBaseDeviceOperationData>GameObject",
    (DeviceOperations_Restore x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_Restore(
    DeviceOperations self,
    SBaseDeviceOperationData operation,
    WeakHandle<game.Object> owner
);

void ResolveDisable(bool disable, WeakHandle<game.Object> owner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "ResolveDisable;BoolGameObject",
    (DeviceOperations_ResolveDisable x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_ResolveDisable(
    DeviceOperations self,
    bool disable,
    WeakHandle<game.Object> owner
);

void ResolveOperations(SToggleOperationData[] operations, WeakHandle<game.Object> owner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "ResolveOperations;script_ref<array<SToggleOperationData>>GameObject",
    (DeviceOperations_ResolveOperations x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_ResolveOperations(
    DeviceOperations self,
    SToggleOperationData[] operations,
    WeakHandle<game.Object> owner
);

void ResolveTeleport(STeleportOperationData teleport, WeakHandle<game.Object> owner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "ResolveTeleport;STeleportOperationDataGameObject",
    (DeviceOperations_ResolveTeleport x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_ResolveTeleport(
    DeviceOperations self,
    STeleportOperationData teleport,
    WeakHandle<game.Object> owner
);

void ResolveItems(SInventoryOperationData[] items, WeakHandle<game.Object> owner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "ResolveItems;script_ref<array<SInventoryOperationData>>GameObject",
    (DeviceOperations_ResolveItems x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_ResolveItems(
    DeviceOperations self,
    SInventoryOperationData[] items,
    WeakHandle<game.Object> owner
);

void ResolveVFXs(SVFXOperationData[] VFXs, WeakHandle<game.Object> owner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "ResolveVFXs;script_ref<array<SVFXOperationData>>GameObject",
    (DeviceOperations_ResolveVFXs x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_ResolveVFXs(
    DeviceOperations self,
    SVFXOperationData[] VFXs,
    WeakHandle<game.Object> owner
);

void ResolveSFXs(SSFXOperationData[] SFXs, WeakHandle<game.Object> owner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "ResolveSFXs;script_ref<array<SSFXOperationData>>GameObject",
    (DeviceOperations_ResolveSFXs x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_ResolveSFXs(
    DeviceOperations self,
    SSFXOperationData[] SFXs,
    WeakHandle<game.Object> owner
);

void ResolveFacts(SFactOperationData[] facts, WeakHandle<game.Object> owner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "ResolveFacts;script_ref<array<SFactOperationData>>GameObject",
    (DeviceOperations_ResolveFacts x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_ResolveFacts(
    DeviceOperations self,
    SFactOperationData[] facts,
    WeakHandle<game.Object> owner
);

void ResolveComponents(SComponentOperationData[] componentsData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "ResolveComponents;script_ref<array<SComponentOperationData>>",
    (DeviceOperations_ResolveComponents x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_ResolveComponents(
    DeviceOperations self,
    SComponentOperationData[] componentsData
);

void ResolveMeshesAppearence(CName appearanceName, WeakHandle<game.Object> owner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "ResolveMeshesAppearence;CNameGameObject",
    (DeviceOperations_ResolveMeshesAppearence x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_ResolveMeshesAppearence(
    DeviceOperations self,
    CName appearanceName,
    WeakHandle<game.Object> owner
);

void ResolveTransformAnimations(STransformAnimationData[] animations, WeakHandle<game.Object> owner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "ResolveTransformAnimations;script_ref<array<STransformAnimationData>>GameObject",
    (DeviceOperations_ResolveTransformAnimations x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_ResolveTransformAnimations(
    DeviceOperations self,
    STransformAnimationData[] animations,
    WeakHandle<game.Object> owner
);

void ResolveWorkspots(SWorkspotData workspot, WeakHandle<game.Object> owner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "ResolveWorkspots;SWorkspotDataGameObject",
    (DeviceOperations_ResolveWorkspots x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_ResolveWorkspots(
    DeviceOperations self,
    SWorkspotData workspot,
    WeakHandle<game.Object> owner
);

void ResolveStims(SStimOperationData[] stims, WeakHandle<game.Object> owner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "ResolveStims;script_ref<array<SStimOperationData>>GameObject",
    (DeviceOperations_ResolveStims x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_ResolveStims(
    DeviceOperations self,
    SStimOperationData[] stims,
    WeakHandle<game.Object> owner
);

void ResolveStatusEffects(SStatusEffectOperationData[] statusEffects, WeakHandle<game.Object> owner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "ResolveStatusEffects;array<SStatusEffectOperationData>GameObject",
    (DeviceOperations_ResolveStatusEffects x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_ResolveStatusEffects(
    DeviceOperations self,
    SStatusEffectOperationData[] statusEffects,
    WeakHandle<game.Object> owner
);

void ResolveDamages(SDamageOperationData[] damages, WeakHandle<game.Object> owner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "ResolveDamages;script_ref<array<SDamageOperationData>>GameObject",
    (DeviceOperations_ResolveDamages x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_ResolveDamages(
    DeviceOperations self,
    SDamageOperationData[] damages,
    WeakHandle<game.Object> owner
);

void EnterWorkspot(Device target, game.Object activator, bool? freeCamera, CName? componentName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "EnterWorkspot;DeviceGameObjectBoolCName",
    (DeviceOperations_EnterWorkspot x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_EnterWorkspot(
    DeviceOperations self,
    Device? target,
    game.Object? activator,
    bool? freeCamera,
    CName? componentName
);

void LeaveWorkspot(game.Object activator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "LeaveWorkspot;GameObject",
    (DeviceOperations_LeaveWorkspot x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_LeaveWorkspot(
    DeviceOperations self,
    game.Object? activator
);

game.FxInstance? GetFxInstance(CName id) RTTI

Generated hook

re.Hooks.Place(
    "DeviceOperations",
    "GetFxInstance;CName",
    (DeviceOperations_GetFxInstance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.FxInstance>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_GetFxInstance(
    DeviceOperations self,
    CName id
);

void RemoveFxInstance(CName id) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "RemoveFxInstance;CName",
    (DeviceOperations_RemoveFxInstance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_RemoveFxInstance(
    DeviceOperations self,
    CName id
);

game.FxInstance? CreateFxInstance(WeakHandle<game.Object> owner, CName id, game.FxResource resource, WorldTransform transform)

RTTI

Generated hook

re.Hooks.Place(
    "DeviceOperations",
    "CreateFxInstance;GameObjectCNameFxResourceWorldTransform",
    (DeviceOperations_CreateFxInstance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.FxInstance>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_CreateFxInstance(
    DeviceOperations self,
    WeakHandle<game.Object> owner,
    CName id,
    game.FxResource resource,
    WorldTransform transform
);

void StoreFxInstance(CName id, game.FxInstance fx) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DeviceOperations",
    "StoreFxInstance;CNameFxInstance",
    (DeviceOperations_StoreFxInstance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DeviceOperations_StoreFxInstance(
    DeviceOperations self,
    CName id,
    game.FxInstance? fx
);