class

SensorDevice

74 properties
180 functions
3 derived classes

Extends ExplosiveDevice BasicDistractionDevice InteractiveDevice Device game.DeviceBase game.Object ent.GameEntity ent.Entity IScriptable ISerializable

Derived

SecurityTurret, SniperNest, SurveillanceCamera

Properties

Property	Type	Offset
`attitudeAgent`	`game.AttitudeAgent?`	`0x4F0`	scripted
`senseComponent`	`sense.Component?`	`0x500`	scripted
`visibleObjectComponent`	`sense.VisibleObjectComponent?`	`0x510`	scripted
`forwardFaceSlotComponent`	`ent.SlotComponent?`	`0x520`	scripted
`targetingComponent`	`game.TargetingComponent?`	`0x530`	scripted
`targetTrackerComponent`	`AITargetTrackerComponent?`	`0x540`	scripted
`cameraComponentInverted`	`game.CameraComponent?`	`0x550`	scripted
`targets`	`Target?[]`	`0x560`	scripted
`currentlyFollowedTarget`	`WeakHandle<game.Object>`	`0x570`	scripted
`currentLookAtEventVert`	`ent.LookAtAddEvent?`	`0x580`	scripted
`currentLookAtEventHor`	`ent.LookAtAddEvent?`	`0x590`	scripted
`HPListenersList`	`TargetedObjectDeathListener?[]`	`0x5A0`	scripted
`sensorDeviceState`	`ESensorDeviceStates`	`0x5B0`	scripted
`sensorWakeState`	`ESensorDeviceWakeState`	`0x5B4`	scripted
`sensorWakeStatePrevious`	`ESensorDeviceWakeState`	`0x5B8`	scripted
`targetingDelayEventID`	`game.DelayID`	`0x5BC`	scripted
`hack_isTargetingDelayEventFilled`	`bool`	`0x5C4`	scripted
`currentResolveDelayEventID`	`game.DelayID`	`0x5C8`	scripted
`hack_isResolveDelayEventFilled`	`bool`	`0x5D0`	scripted
`animFeatureData`	`AnimFeature_SensorDevice?`	`0x5D8`	scripted
`animFeatureDataName`	`CName`	`0x5E8`	scripted
`targetLostBySensesDelayEventID`	`game.DelayID`	`0x5F0`	scripted
`hack_isTargetLostBySensesDelEvtFilled`	`bool`	`0x5F8`	scripted
`initialAttitude`	`CName`	`0x600`	scripted
`detectionFactorMultiplier`	`float`	`0x608`	scripted
`taggedListenerCallback`	`red.CallbackObject?`	`0x610`	scripted
`lightScanRefs`	`game.LightComponent?[]`	`0x620`	scripted
`lightAttitudeRefs`	`game.LightComponent?[]`	`0x630`	scripted
`lightInfoRefs`	`game.LightComponent?[]`	`0x640`	scripted
`lightColors`	`LedColors_SensorDevice`	`0x650`	scripted
`deviceFXRecord`	`game.data.DeviceFX_Record?`	`0x680`	scripted
`scanGameEffect`	`game.EffectInstance?`	`0x690`	scripted
`scanFXSlotName`	`CName`	`0x6A0`	scripted
`visionConeEffectInstance`	`game.EffectInstance?`	`0x6A8`	scripted
`idleGameEffectInstance`	`game.EffectInstance?`	`0x6B8`	scripted
`targetForcedFormTagKill`	`bool`	`0x6C8`	scripted
`hasSupport`	`bool`	`0x6C9`	scripted
`defaultSensePreset`	`TDBID`	`0x6CC`	scripted
`keepHostilityTowardsPlayerHostiles`	`bool`	`0x6D4`	scripted
`hostileUpdateTowardsPlayerHostilesDelayed`	`bool`	`0x6D5`	scripted
`elementsToHideOnTCS`	`CName[]`	`0x6D8`	scripted
`elementsToHideOnTCSRefs`	`ent.IPlacedComponent?[]`	`0x6E8`	scripted
`previoustagKillList`	`WeakHandle<game.Object>[]`	`0x6F8`	scripted
`playIdleSoundOnIdle`	`bool`	`0x708`	scripted
`idleSound`	`CName`	`0x710`	scripted
`idleSoundStop`	`CName`	`0x718`	scripted
`soundDeviceON`	`CName`	`0x720`	scripted
`soundDeviceOFF`	`CName`	`0x728`	scripted
`idleSoundIsPlaying`	`bool`	`0x730`	scripted
`soundDeviceDestroyed`	`CName`	`0x738`	scripted
`soundDetectionLoop`	`CName`	`0x740`	scripted
`soundDetectionLoopStop`	`CName`	`0x748`	scripted
`isPLAYERSAFETargetLock`	`bool`	`0x750`	scripted
`playerDetected`	`bool`	`0x751`	scripted
`clientForceSetAnimFeature`	`bool`	`0x752`	scripted
`playerControlData`	`PlayerControlDeviceData`	`0x754`	scripted
`engineTimeInSec`	`float`	`0x75C`	scripted
`TCExitEngineTime`	`float`	`0x760`	scripted
`hack_wasTargetReevaluated`	`bool`	`0x764`	scripted
`hack_wasSSOutupFromSelf`	`bool`	`0x765`	scripted
`degbu_SS_inputsSend`	`int`	`0x768`	scripted
`debug_SS_inputsSendTargetLock`	`int`	`0x76C`	scripted
`debug_SS_inputsSendIntresting`	`int`	`0x770`	scripted
`debug_SS_inputsSendLoseTarget`	`int`	`0x774`	scripted
`debug_SS_outputRecieved`	`int`	`0x778`	scripted
`debug_SS_outputFormSelfRecieved`	`int`	`0x77C`	scripted
`debug_SS_outputFromElseRecieved`	`int`	`0x780`	scripted
`debug_SS_reevaluatesDone`	`int`	`0x784`	scripted
`debug_SS_trespassingRecieved`	`int`	`0x788`	scripted
`debug_SS_TargetAssessmentRequest`	`int`	`0x78C`	scripted
`minPitch`	`float`	`0x790`	scripted
`maxPitch`	`float`	`0x794`	scripted
`minYaw`	`float`	`0x798`	scripted
`maxYaw`	`float`	`0x79C`	scripted

Functions

void ResolveConnectionWithSecuritySystemByTask() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ResolveConnectionWithSecuritySystemByTask;",
    (SensorDevice_ResolveConnectionWithSecuritySystemByTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ResolveConnectionWithSecuritySystemByTask(
    SensorDevice self
);

void ResolveConnectionWithSecuritySystemTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ResolveConnectionWithSecuritySystemTask;ScriptTaskData",
    (SensorDevice_ResolveConnectionWithSecuritySystemTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void ResolveConnectionWithSecuritySystem() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ResolveConnectionWithSecuritySystem;",
    (SensorDevice_ResolveConnectionWithSecuritySystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ResolveConnectionWithSecuritySystem(
    SensorDevice self
);

void HandleSecuritySystemOutputByTask() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "HandleSecuritySystemOutputByTask;",
    (SensorDevice_HandleSecuritySystemOutputByTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_HandleSecuritySystemOutputByTask(
    SensorDevice self
);

void HandleSecuritySystemOutputTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "HandleSecuritySystemOutputTask;ScriptTaskData",
    (SensorDevice_HandleSecuritySystemOutputTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void HandleSecuritySystemOutput() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "HandleSecuritySystemOutput;",
    (SensorDevice_HandleSecuritySystemOutput x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_HandleSecuritySystemOutput(
    SensorDevice self
);

bool OnRequestComponents(ent.EntityRequestComponentsInterface ri) overrideRTTI

Generated hook

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

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

bool OnTakeControl(ent.EntityResolveComponentsInterface ri) overrideRTTI

Generated hook

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

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

void OnMaraudersMapDeviceDebug(world.MaraudersMapDevicesSink sink) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "OnMaraudersMapDeviceDebug;MaraudersMapDevicesSink",
    (SensorDevice_OnMaraudersMapDeviceDebug x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnMaraudersMapDeviceDebug(
    SensorDevice self,
    world.MaraudersMapDevicesSink? sink
);

void ResolveGameplayState() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ResolveGameplayState;",
    (SensorDevice_ResolveGameplayState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ResolveGameplayState(
    SensorDevice self
);

bool OnPostInitialize(ent.PostInitializeEvent evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnPostInitialize",
    (SensorDevice_OnPostInitialize x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnPostInitialize(
    SensorDevice self,
    ent.PostInitializeEvent? evt
);

bool OnPreUninitialize(ent.PreUninitializeEvent evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnPreUninitialize",
    (SensorDevice_OnPreUninitialize x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnPreUninitialize(
    SensorDevice self,
    ent.PreUninitializeEvent? evt
);

bool OnGameAttached() overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnGameAttached",
    (SensorDevice_OnGameAttached x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnGameAttached(
    SensorDevice self
);

bool OnDetach() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnDetach(
    SensorDevice self
);

bool OnAttitudeChanged(game.events.AttitudeChangedEvent evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnAttitudeChanged",
    (SensorDevice_OnAttitudeChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnAttitudeChanged(
    SensorDevice self,
    game.events.AttitudeChangedEvent? evt
);

bool IsSensor() overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "IsSensor;",
    (SensorDevice_IsSensor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_IsSensor(
    SensorDevice self
);

bool IsPrevention() overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "IsPrevention;",
    (SensorDevice_IsPrevention x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_IsPrevention(
    SensorDevice self
);

game.data.DeviceFX_Record? GetDeviceFXRecord() RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "GetDeviceFXRecord;",
    (SensorDevice_GetDeviceFXRecord x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.DeviceFX_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_GetDeviceFXRecord(
    SensorDevice self
);

bool IsSurveillanceCamera() RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "IsSurveillanceCamera;",
    (SensorDevice_IsSurveillanceCamera x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_IsSurveillanceCamera(
    SensorDevice self
);

bool HasSupport() RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "HasSupport;",
    (SensorDevice_HasSupport x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_HasSupport(
    SensorDevice self
);

void SetHasSupport(bool value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "SetHasSupport;Bool",
    (SensorDevice_SetHasSupport x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_SetHasSupport(
    SensorDevice self,
    bool value
);

void CreateLightSettings() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "CreateLightSettings;",
    (SensorDevice_CreateLightSettings x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_CreateLightSettings(
    SensorDevice self
);

game.AttitudeAgent? GetAttitudeAgent() overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "GetAttitudeAgent;",
    (SensorDevice_GetAttitudeAgent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.AttitudeAgent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_GetAttitudeAgent(
    SensorDevice self
);

AITargetTrackerComponent? GetTargetTrackerComponent() overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "GetTargetTrackerComponent;",
    (SensorDevice_GetTargetTrackerComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.AITargetTrackerComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_GetTargetTrackerComponent(
    SensorDevice self
);

sense.Component? GetSensesComponent() overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "GetSensesComponent;",
    (SensorDevice_GetSensesComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.sense.SenseComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_GetSensesComponent(
    SensorDevice self
);

sense.VisibleObjectComponent? GetVisibleObjectComponent() RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "GetVisibleObjectComponent;",
    (SensorDevice_GetVisibleObjectComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.sense.VisibleObjectComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_GetVisibleObjectComponent(
    SensorDevice self
);

SensorDeviceController? GetController() overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "GetController;",
    (SensorDevice_GetController x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.SensorDeviceController>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_GetController(
    SensorDevice self
);

SensorDeviceControllerPS? GetDevicePS() overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "GetDevicePS;",
    (SensorDevice_GetDevicePS x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.SensorDeviceControllerPS>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_GetDevicePS(
    SensorDevice self
);

AnimFeature_SensorDevice? GetAnimFeatureInCurrentState() RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "GetAnimFeatureInCurrentState;",
    (SensorDevice_GetAnimFeatureInCurrentState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.AnimFeature_SensorDevice>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_GetAnimFeatureInCurrentState(
    SensorDevice self
);

bool IsPlayerSafeTargetLock() RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "IsPlayerSafeTargetLock;",
    (SensorDevice_IsPlayerSafeTargetLock x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_IsPlayerSafeTargetLock(
    SensorDevice self
);

bool IsTargetForcedFromTagKill() RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "IsTargetForcedFromTagKill;",
    (SensorDevice_IsTargetForcedFromTagKill x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_IsTargetForcedFromTagKill(
    SensorDevice self
);

Target?[] GetCurrentTargets() RTTI

ESensorDeviceStates GetSensorDeviceState() RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "GetSensorDeviceState;",
    (SensorDevice_GetSensorDeviceState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ESensorDeviceStates>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_GetSensorDeviceState(
    SensorDevice self
);

CameraRotationData GetRotationData() RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "GetRotationData;",
    (SensorDevice_GetRotationData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CameraRotationData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_GetRotationData(
    SensorDevice self
);

void UpdateAnimFeatureWakeState() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "UpdateAnimFeatureWakeState;",
    (SensorDevice_UpdateAnimFeatureWakeState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_UpdateAnimFeatureWakeState(
    SensorDevice self
);

void ApplyAnimFeatureToReplicate(game.Object obj, CName inputName, anim.AnimFeature value) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ApplyAnimFeatureToReplicate;GameObjectCNameAnimFeature",
    (SensorDevice_ApplyAnimFeatureToReplicate x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ApplyAnimFeatureToReplicate(
    SensorDevice self,
    game.Object? obj,
    CName inputName,
    anim.AnimFeature? value
);

WeakHandle<game.Object> GetCurrentlyFollowedTarget() RTTI

void TurnOffDevice() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct SensorDevice_TurnOffDevice(
    SensorDevice self
);

void TurnOffSenseComponent() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "TurnOffSenseComponent;",
    (SensorDevice_TurnOffSenseComponent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_TurnOffSenseComponent(
    SensorDevice self
);

bool OnTurnOnVisibilitySenseComponent(TurnOnVisibilitySenseComponent evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnTurnOnVisibilitySenseComponent",
    (SensorDevice_OnTurnOnVisibilitySenseComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnTurnOnVisibilitySenseComponent(
    SensorDevice self,
    TurnOnVisibilitySenseComponent? evt
);

void TurnOnDevice() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct SensorDevice_TurnOnDevice(
    SensorDevice self
);

bool OnHit(game.events.HitEvent hit) overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnHit",
    (SensorDevice_OnHit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnHit(
    SensorDevice self,
    game.events.HitEvent? hit
);

void DamagePipelineFinalized(game.events.HitEvent evt) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "DamagePipelineFinalized;gameHitEvent",
    (SensorDevice_DamagePipelineFinalized x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_DamagePipelineFinalized(
    SensorDevice self,
    game.events.HitEvent? evt
);

bool OnDeath(game.events.DeathEvent evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnDeath",
    (SensorDevice_OnDeath x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnDeath(
    SensorDevice self,
    game.events.DeathEvent? evt
);

void DestroySensor() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "DestroySensor;",
    (SensorDevice_DestroySensor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_DestroySensor(
    SensorDevice self
);

Vector4 GetHitSourcePosition(ent.EntityID hitSourceEntityID) overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "GetHitSourcePosition;EntityID",
    (SensorDevice_GetHitSourcePosition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_GetHitSourcePosition(
    SensorDevice self,
    ent.EntityID hitSourceEntityID
);

Vector4 GetPotentialHitSourcePosition(ent.EntityID hitSourceEntityID) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "GetPotentialHitSourcePosition;EntityID",
    (SensorDevice_GetPotentialHitSourcePosition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_GetPotentialHitSourcePosition(
    SensorDevice self,
    ent.EntityID hitSourceEntityID
);

void RegisterListenerOnTargetHP(game.Object target) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "RegisterListenerOnTargetHP;GameObject",
    (SensorDevice_RegisterListenerOnTargetHP x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_RegisterListenerOnTargetHP(
    SensorDevice self,
    game.Object? target
);

void UnregisterListenerOnTargetHP(WeakHandle<game.Object> listeningObject, TargetedObjectDeathListener listener) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "UnregisterListenerOnTargetHP;GameObjectTargetedObjectDeathListener",
    (SensorDevice_UnregisterListenerOnTargetHP x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_UnregisterListenerOnTargetHP(
    SensorDevice self,
    WeakHandle<game.Object> listeningObject,
    TargetedObjectDeathListener? listener
);

void UnregisterListenerOnTargetHP(WeakHandle<game.Object> listeningObject, WeakHandle<game.Object> lostObject) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "UnregisterListenerOnTargetHP;GameObjectGameObject",
    (SensorDevice_UnregisterListenerOnTargetHP2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_UnregisterListenerOnTargetHP2(
    SensorDevice self,
    WeakHandle<game.Object> listeningObject,
    WeakHandle<game.Object> lostObject
);

bool OnUnregisterListenerOnTargetHPEvent(UnregisterListenerOnTargetHPEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnUnregisterListenerOnTargetHPEvent",
    (SensorDevice_OnUnregisterListenerOnTargetHPEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnUnregisterListenerOnTargetHPEvent(
    SensorDevice self,
    UnregisterListenerOnTargetHPEvent? evt
);

void ClearAllHPListeners() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ClearAllHPListeners;",
    (SensorDevice_ClearAllHPListeners x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ClearAllHPListeners(
    SensorDevice self
);

bool OnSetJammedEvent(SetJammedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnSetJammedEvent",
    (SensorDevice_OnSetJammedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnSetJammedEvent(
    SensorDevice self,
    SetJammedEvent? evt
);

bool SetAsIntrestingTarget(WeakHandle<game.Object> target) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "SetAsIntrestingTarget;GameObject",
    (SensorDevice_SetAsIntrestingTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_SetAsIntrestingTarget(
    SensorDevice self,
    WeakHandle<game.Object> target
);

void OnValidTargetAppears(WeakHandle<game.Object> target) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "OnValidTargetAppears;GameObject",
    (SensorDevice_OnValidTargetAppears x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnValidTargetAppears(
    SensorDevice self,
    WeakHandle<game.Object> target
);

void OnCurrentTargetAppears(WeakHandle<game.Object> target) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "OnCurrentTargetAppears;GameObject",
    (SensorDevice_OnCurrentTargetAppears x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnCurrentTargetAppears(
    SensorDevice self,
    WeakHandle<game.Object> target
);

float GetBehaviourTimeToTakeAction() RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "GetBehaviourTimeToTakeAction;",
    (SensorDevice_GetBehaviourTimeToTakeAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_GetBehaviourTimeToTakeAction(
    SensorDevice self
);

void ChangeTemporaryAttitude() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ChangeTemporaryAttitude;",
    (SensorDevice_ChangeTemporaryAttitude x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ChangeTemporaryAttitude(
    SensorDevice self
);

void CacheInitialAttitude() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "CacheInitialAttitude;",
    (SensorDevice_CacheInitialAttitude x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_CacheInitialAttitude(
    SensorDevice self
);

void ClearInitialAttitude() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ClearInitialAttitude;",
    (SensorDevice_ClearInitialAttitude x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ClearInitialAttitude(
    SensorDevice self
);

bool IsTemporaryAttitudeChanged() RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "IsTemporaryAttitudeChanged;",
    (SensorDevice_IsTemporaryAttitudeChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_IsTemporaryAttitudeChanged(
    SensorDevice self
);

void RevertTemporaryAttitude() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "RevertTemporaryAttitude;",
    (SensorDevice_RevertTemporaryAttitude x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_RevertTemporaryAttitude(
    SensorDevice self
);

bool OnQhackExecuted(QhackExecuted evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnQhackExecuted",
    (SensorDevice_OnQhackExecuted x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnQhackExecuted(
    SensorDevice self,
    QhackExecuted? evt
);

void OnValidTargetDisappears(WeakHandle<game.Object> target) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "OnValidTargetDisappears;GameObject",
    (SensorDevice_OnValidTargetDisappears x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnValidTargetDisappears(
    SensorDevice self,
    WeakHandle<game.Object> target
);

void OnAllValidTargetsDisappears() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "OnAllValidTargetsDisappears;",
    (SensorDevice_OnAllValidTargetsDisappears x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnAllValidTargetsDisappears(
    SensorDevice self
);

void ToggleAreaIndicator(bool turnOn) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ToggleAreaIndicator;Bool",
    (SensorDevice_ToggleAreaIndicator x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ToggleAreaIndicator(
    SensorDevice self,
    bool turnOn
);

void SendDisableAreaIndicatorEvent() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "SendDisableAreaIndicatorEvent;",
    (SensorDevice_SendDisableAreaIndicatorEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_SendDisableAreaIndicatorEvent(
    SensorDevice self
);

void StartLockingTarget(float lockingTime) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "StartLockingTarget;Float",
    (SensorDevice_StartLockingTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_StartLockingTarget(
    SensorDevice self,
    float lockingTime
);

void BreakTargeting() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "BreakTargeting;",
    (SensorDevice_BreakTargeting x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_BreakTargeting(
    SensorDevice self
);

void BreakBehaviourResolve() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "BreakBehaviourResolve;",
    (SensorDevice_BreakBehaviourResolve x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_BreakBehaviourResolve(
    SensorDevice self
);

bool OnTargetLocked(TargetLockedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnTargetLocked",
    (SensorDevice_OnTargetLocked x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnTargetLocked(
    SensorDevice self,
    TargetLockedEvent? evt
);

void SetQuestVisibility(bool isVisible) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "SetQuestVisibility;Bool",
    (SensorDevice_SetQuestVisibility x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_SetQuestVisibility(
    SensorDevice self,
    bool isVisible
);

bool OnDetectionRiseEvent(DetectionRiseEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnDetectionRiseEvent",
    (SensorDevice_OnDetectionRiseEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnDetectionRiseEvent(
    SensorDevice self,
    DetectionRiseEvent? evt
);

bool OnOnDetectedEvent(sense.OnDetectedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnOnDetectedEvent",
    (SensorDevice_OnOnDetectedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnOnDetectedEvent(
    SensorDevice self,
    sense.OnDetectedEvent? evt
);

bool OnOnRemoveDetection(sense.OnRemoveDetection evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnOnRemoveDetection",
    (SensorDevice_OnOnRemoveDetection x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnOnRemoveDetection(
    SensorDevice self,
    sense.OnRemoveDetection? evt
);

void SenseLoseTarget(game.Object target) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "SenseLoseTarget;GameObject",
    (SensorDevice_SenseLoseTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_SenseLoseTarget(
    SensorDevice self,
    game.Object? target
);

bool OnLostTargetDelayFalsePositivesDelay(LostTargetDelayFalsePositivesDelay evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnLostTargetDelayFalsePositivesDelay",
    (SensorDevice_OnLostTargetDelayFalsePositivesDelay x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnLostTargetDelayFalsePositivesDelay(
    SensorDevice self,
    LostTargetDelayFalsePositivesDelay? evt
);

bool OnEnterShapeEvent(sense.OnEnterShapeEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnEnterShapeEvent",
    (SensorDevice_OnEnterShapeEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnEnterShapeEvent(
    SensorDevice self,
    sense.OnEnterShapeEvent? evt
);

bool OnSenseVisibilityEvent(sense.VisibilityEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnSenseVisibilityEvent",
    (SensorDevice_OnSenseVisibilityEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnSenseVisibilityEvent(
    SensorDevice self,
    sense.VisibilityEvent? evt
);

bool IsCurrentTargetOutOfSenseRange(game.Object lostTarget) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "IsCurrentTargetOutOfSenseRange;GameObject",
    (SensorDevice_IsCurrentTargetOutOfSenseRange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_IsCurrentTargetOutOfSenseRange(
    SensorDevice self,
    game.Object? lostTarget
);

float GetSenseRange() RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "GetSenseRange;",
    (SensorDevice_GetSenseRange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_GetSenseRange(
    SensorDevice self
);

void LoseTargetFalsePositiveDelay(WeakHandle<game.Object> target) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "LoseTargetFalsePositiveDelay;GameObject",
    (SensorDevice_LoseTargetFalsePositiveDelay x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_LoseTargetFalsePositiveDelay(
    SensorDevice self,
    WeakHandle<game.Object> target
);

float GetDetectionFactor() RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "GetDetectionFactor;",
    (SensorDevice_GetDetectionFactor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_GetDetectionFactor(
    SensorDevice self
);

bool OnSetDetectionMultiplier(SetDetectionMultiplier evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnSetDetectionMultiplier",
    (SensorDevice_OnSetDetectionMultiplier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnSetDetectionMultiplier(
    SensorDevice self,
    SetDetectionMultiplier? evt
);

void SetDetectionMultiplier(float multiplier) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "SetDetectionMultiplier;Float",
    (SensorDevice_SetDetectionMultiplier x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_SetDetectionMultiplier(
    SensorDevice self,
    float multiplier
);

void CancelLosetargetFalsePositiveDelay() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "CancelLosetargetFalsePositiveDelay;",
    (SensorDevice_CancelLosetargetFalsePositiveDelay x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_CancelLosetargetFalsePositiveDelay(
    SensorDevice self
);

void CancelPLAYERSAFEDelayEvent() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "CancelPLAYERSAFEDelayEvent;",
    (SensorDevice_CancelPLAYERSAFEDelayEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_CancelPLAYERSAFEDelayEvent(
    SensorDevice self
);

void ForceCancelAllForcedBehaviours() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ForceCancelAllForcedBehaviours;",
    (SensorDevice_ForceCancelAllForcedBehaviours x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ForceCancelAllForcedBehaviours(
    SensorDevice self
);

void RecognizeTarget(WeakHandle<game.Object> newObject, bool? questForcedIntresting) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "RecognizeTarget;GameObjectBool",
    (SensorDevice_RecognizeTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_RecognizeTarget(
    SensorDevice self,
    WeakHandle<game.Object> newObject,
    bool? questForcedIntresting
);

void LoseTarget(WeakHandle<game.Object> lostObject, bool? forceRemoveTarget) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "LoseTarget;GameObjectBool",
    (SensorDevice_LoseTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_LoseTarget(
    SensorDevice self,
    WeakHandle<game.Object> lostObject,
    bool? forceRemoveTarget
);

bool OnSecuritySystemEnabled(SecuritySystemEnabled evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnSecuritySystemEnabled",
    (SensorDevice_OnSecuritySystemEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnSecuritySystemEnabled(
    SensorDevice self,
    SecuritySystemEnabled? evt
);

bool OnSecuritySystemSupport(SecuritySystemSupport evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnSecuritySystemSupport",
    (SensorDevice_OnSecuritySystemSupport x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnSecuritySystemSupport(
    SensorDevice self,
    SecuritySystemSupport? evt
);

bool OnSecuritySystemOutput(SecuritySystemOutput evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnSecuritySystemOutput",
    (SensorDevice_OnSecuritySystemOutput x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnSecuritySystemOutput(
    SensorDevice self,
    SecuritySystemOutput? evt
);

bool OnSecuritySystemForceAttitudeChange(SecuritySystemForceAttitudeChange evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnSecuritySystemForceAttitudeChange",
    (SensorDevice_OnSecuritySystemForceAttitudeChange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnSecuritySystemForceAttitudeChange(
    SensorDevice self,
    SecuritySystemForceAttitudeChange? evt
);

void BlinkSecurityLight(int howManyTimes) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "BlinkSecurityLight;Int32",
    (SensorDevice_BlinkSecurityLight x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_BlinkSecurityLight(
    SensorDevice self,
    int howManyTimes
);

bool OnTargetAssessmentRequest(TargetAssessmentRequest evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnTargetAssessmentRequest",
    (SensorDevice_OnTargetAssessmentRequest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnTargetAssessmentRequest(
    SensorDevice self,
    TargetAssessmentRequest? evt
);

bool OnReprimandUpdate(ReprimandUpdate evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnReprimandUpdate",
    (SensorDevice_OnReprimandUpdate x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnReprimandUpdate(
    SensorDevice self,
    ReprimandUpdate? evt
);

void StartReprimand() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "StartReprimand;",
    (SensorDevice_StartReprimand x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_StartReprimand(
    SensorDevice self
);

void BreakReprimand(bool? wasSucesfull) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "BreakReprimand;Bool",
    (SensorDevice_BreakReprimand x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_BreakReprimand(
    SensorDevice self,
    bool? wasSucesfull
);

void SendDefaultSSNotification(WeakHandle<game.Object> target, bool securityIntresting) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "SendDefaultSSNotification;GameObjectBool",
    (SensorDevice_SendDefaultSSNotification x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_SendDefaultSSNotification(
    SensorDevice self,
    WeakHandle<game.Object> target,
    bool securityIntresting
);

void SetSensePresetBasedOnSSState() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "SetSensePresetBasedOnSSState;",
    (SensorDevice_SetSensePresetBasedOnSSState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_SetSensePresetBasedOnSSState(
    SensorDevice self
);

WeakHandle<game.Object> GetForcedTargetObject() RTTI

bool OnStartFollowingForcedTarget(QuestFollowTarget evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnStartFollowingForcedTarget",
    (SensorDevice_OnStartFollowingForcedTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnStartFollowingForcedTarget(
    SensorDevice self,
    QuestFollowTarget? evt
);

bool OnStopFollowingForcedTarget(QuestStopFollowingTarget evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnStopFollowingForcedTarget",
    (SensorDevice_OnStopFollowingForcedTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnStopFollowingForcedTarget(
    SensorDevice self,
    QuestStopFollowingTarget? evt
);

bool OnStartQuestLookAtTarget(QuestLookAtTarget evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnStartQuestLookAtTarget",
    (SensorDevice_OnStartQuestLookAtTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnStartQuestLookAtTarget(
    SensorDevice self,
    QuestLookAtTarget? evt
);

bool OnStopQuestStopLookAtTarget(QuestStopLookAtTarget evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnStopQuestStopLookAtTarget",
    (SensorDevice_OnStopQuestStopLookAtTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnStopQuestStopLookAtTarget(
    SensorDevice self,
    QuestStopLookAtTarget? evt
);

bool OnQuestSetDetectionToTrue(QuestSetDetectionToTrue evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnQuestSetDetectionToTrue",
    (SensorDevice_OnQuestSetDetectionToTrue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnQuestSetDetectionToTrue(
    SensorDevice self,
    QuestSetDetectionToTrue? evt
);

bool OnQuestSetDetectionToFalse(QuestSetDetectionToFalse evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnQuestSetDetectionToFalse",
    (SensorDevice_OnQuestSetDetectionToFalse x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnQuestSetDetectionToFalse(
    SensorDevice self,
    QuestSetDetectionToFalse? evt
);

bool OnQuestForceScanEffect(QuestForceScanEffect evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnQuestForceScanEffect",
    (SensorDevice_OnQuestForceScanEffect x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnQuestForceScanEffect(
    SensorDevice self,
    QuestForceScanEffect? evt
);

bool OnQuestForceScanEffectStop(QuestForceScanEffectStop evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnQuestForceScanEffectStop",
    (SensorDevice_OnQuestForceScanEffectStop x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnQuestForceScanEffectStop(
    SensorDevice self,
    QuestForceScanEffectStop? evt
);

bool OnQuestForceAttitude(QuestForceAttitude evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnQuestForceAttitude",
    (SensorDevice_OnQuestForceAttitude x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnQuestForceAttitude(
    SensorDevice self,
    QuestForceAttitude? evt
);

void StartBehaviourResolve(ESensorDeviceStates newState) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "StartBehaviourResolve;ESensorDeviceStates",
    (SensorDevice_StartBehaviourResolve x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_StartBehaviourResolve(
    SensorDevice self,
    ESensorDeviceStates newState
);

void ForceStartBehaviorResolve(ESensorDeviceStates newState) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ForceStartBehaviorResolve;ESensorDeviceStates",
    (SensorDevice_ForceStartBehaviorResolve x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ForceStartBehaviorResolve(
    SensorDevice self,
    ESensorDeviceStates newState
);

ESensorDeviceStates CanResolveStateChange(ESensorDeviceStates newState) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "CanResolveStateChange;ESensorDeviceStates",
    (SensorDevice_CanResolveStateChange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ESensorDeviceStates>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_CanResolveStateChange(
    SensorDevice self,
    ESensorDeviceStates newState
);

bool OnResolveSensorDeviceBehaviour(ResolveSensorDeviceBehaviour evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnResolveSensorDeviceBehaviour",
    (SensorDevice_OnResolveSensorDeviceBehaviour x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnResolveSensorDeviceBehaviour(
    SensorDevice self,
    ResolveSensorDeviceBehaviour? evt
);

void ResolveLogicIDLE() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ResolveLogicIDLE;",
    (SensorDevice_ResolveLogicIDLE x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ResolveLogicIDLE(
    SensorDevice self
);

void ResolveLogicLOSETARGET(int iterator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ResolveLogicLOSETARGET;Int32",
    (SensorDevice_ResolveLogicLOSETARGET x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ResolveLogicLOSETARGET(
    SensorDevice self,
    int iterator
);

void ResolveLogicTARGETLOCK() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ResolveLogicTARGETLOCK;",
    (SensorDevice_ResolveLogicTARGETLOCK x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ResolveLogicTARGETLOCK(
    SensorDevice self
);

void ResolveLogicJAMMER() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ResolveLogicJAMMER;",
    (SensorDevice_ResolveLogicJAMMER x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ResolveLogicJAMMER(
    SensorDevice self
);

void CreateLookAt(Vector4? position, game.Object? otherTarget) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "CreateLookAt;Vector4GameObject",
    (SensorDevice_CreateLookAt x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_CreateLookAt(
    SensorDevice self,
    Vector4? position,
    game.Object? otherTarget
);

ent.LookAtAddEvent? SetupLookAtProperties(TDBID recordID, Vector4? position, game.Object? otherTarget) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "SetupLookAtProperties;TweakDBIDVector4GameObject",
    (SensorDevice_SetupLookAtProperties x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.LookAtAddEvent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_SetupLookAtProperties(
    SensorDevice self,
    TDBID recordID,
    Vector4? position,
    game.Object? otherTarget
);

void OverrideLookAtSetupVert(out ent.LookAtAddEvent lookAtEntityEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "OverrideLookAtSetupVert;LookAtAddEvent",
    (SensorDevice_OverrideLookAtSetupVert x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OverrideLookAtSetupVert(
    SensorDevice self,
    ent.LookAtAddEvent? lookAtEntityEvent
);

void OverrideLookAtSetupHor(out ent.LookAtAddEvent lookAtEntityEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "OverrideLookAtSetupHor;LookAtAddEvent",
    (SensorDevice_OverrideLookAtSetupHor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OverrideLookAtSetupHor(
    SensorDevice self,
    ent.LookAtAddEvent? lookAtEntityEvent
);

void ResolveLogicTARGETRECEIVED(int iterator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ResolveLogicTARGETRECEIVED;Int32",
    (SensorDevice_ResolveLogicTARGETRECEIVED x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ResolveLogicTARGETRECEIVED(
    SensorDevice self,
    int iterator
);

void ResolveLogicREPRIMEND() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ResolveLogicREPRIMEND;",
    (SensorDevice_ResolveLogicREPRIMEND x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ResolveLogicREPRIMEND(
    SensorDevice self
);

void SetLookAtPositionProviderOnFollowedTarget(ent.LookAtAddEvent evt, game.Object? otherTarget) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "SetLookAtPositionProviderOnFollowedTarget;LookAtAddEventGameObject",
    (SensorDevice_SetLookAtPositionProviderOnFollowedTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_SetLookAtPositionProviderOnFollowedTarget(
    SensorDevice self,
    ent.LookAtAddEvent? evt,
    game.Object? otherTarget
);

void ModeLookAtCurrentTarget() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ModeLookAtCurrentTarget;",
    (SensorDevice_ModeLookAtCurrentTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ModeLookAtCurrentTarget(
    SensorDevice self
);

void ModeSearch(float? speedMultipler) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ModeSearch;Float",
    (SensorDevice_ModeSearch x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ModeSearch(
    SensorDevice self,
    float? speedMultipler
);

void ModeIdleNoTarget() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ModeIdleNoTarget;",
    (SensorDevice_ModeIdleNoTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ModeIdleNoTarget(
    SensorDevice self
);

void ModeStopMovementAtTargetPos(Vector4 targetPosition) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ModeStopMovementAtTargetPos;Vector4",
    (SensorDevice_ModeStopMovementAtTargetPos x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ModeStopMovementAtTargetPos(
    SensorDevice self,
    Vector4 targetPosition
);

void LookAtStop() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "LookAtStop;",
    (SensorDevice_LookAtStop x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_LookAtStop(
    SensorDevice self
);

void OneShotLookAtPosition(Vector4 targetPos, bool? forcedLook) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "OneShotLookAtPosition;Vector4Bool",
    (SensorDevice_OneShotLookAtPosition x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OneShotLookAtPosition(
    SensorDevice self,
    Vector4 targetPos,
    bool? forcedLook
);

void ForcedLookAtEntityWithoutTargetMODE(game.Object target) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ForcedLookAtEntityWithoutTargetMODE;GameObject",
    (SensorDevice_ForcedLookAtEntityWithoutTargetMODE x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ForcedLookAtEntityWithoutTargetMODE(
    SensorDevice self,
    game.Object? target
);

bool OnSetDeviceTagKillMode(SetDeviceTagKillMode evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnSetDeviceTagKillMode",
    (SensorDevice_OnSetDeviceTagKillMode x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnSetDeviceTagKillMode(
    SensorDevice self,
    SetDeviceTagKillMode? evt
);

void AddTaggedListener(game.Object objectt, CName funcName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "AddTaggedListener;GameObjectCName",
    (SensorDevice_AddTaggedListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_AddTaggedListener(
    SensorDevice self,
    game.Object? objectt,
    CName funcName
);

bool CheckIfTargetIsTaggedByPlayer(WeakHandle<game.Object> objectt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "CheckIfTargetIsTaggedByPlayer;GameObject",
    (SensorDevice_CheckIfTargetIsTaggedByPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_CheckIfTargetIsTaggedByPlayer(
    SensorDevice self,
    WeakHandle<game.Object> objectt
);

void ChangeAttiudetowardsTag(WeakHandle<game.Object>[] currentList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ChangeAttiudetowardsTag;script_ref<array<GameObject>>",
    (SensorDevice_ChangeAttiudetowardsTag x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ChangeAttiudetowardsTag(
    SensorDevice self,
    WeakHandle<game.Object>[] currentList
);

bool OnSetDeviceAttitude(SetDeviceAttitude evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnSetDeviceAttitude",
    (SensorDevice_OnSetDeviceAttitude x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnSetDeviceAttitude(
    SensorDevice self,
    SetDeviceAttitude? evt
);

void SetDeviceNeutral(SetDeviceAttitude evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "SetDeviceNeutral;SetDeviceAttitude",
    (SensorDevice_SetDeviceNeutral x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_SetDeviceNeutral(
    SensorDevice self,
    SetDeviceAttitude? evt
);

void SetDeviceFriendly(SetDeviceAttitude evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "SetDeviceFriendly;SetDeviceAttitude",
    (SensorDevice_SetDeviceFriendly x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_SetDeviceFriendly(
    SensorDevice self,
    SetDeviceAttitude? evt
);

void KeepHostilityTowardsPlayerHostiles(bool keep) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "KeepHostilityTowardsPlayerHostiles;Bool",
    (SensorDevice_KeepHostilityTowardsPlayerHostiles x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_KeepHostilityTowardsPlayerHostiles(
    SensorDevice self,
    bool keep
);

void SetHostileTowardsPlayerHostiles(bool? useTargetingSystem) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "SetHostileTowardsPlayerHostiles;Bool",
    (SensorDevice_SetHostileTowardsPlayerHostiles x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_SetHostileTowardsPlayerHostiles(
    SensorDevice self,
    bool? useTargetingSystem
);

void ScheduleHostileUpdateTowardsPlayerHostiles() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ScheduleHostileUpdateTowardsPlayerHostiles;",
    (SensorDevice_ScheduleHostileUpdateTowardsPlayerHostiles x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ScheduleHostileUpdateTowardsPlayerHostiles(
    SensorDevice self
);

bool OnHostileUpdateTowardsPlayerHostiles(HostileUpdateTowardsPlayerHostiles evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnHostileUpdateTowardsPlayerHostiles",
    (SensorDevice_OnHostileUpdateTowardsPlayerHostiles x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnHostileUpdateTowardsPlayerHostiles(
    SensorDevice self,
    HostileUpdateTowardsPlayerHostiles? evt
);

bool OnForcePlayerIgnore(ForceIgnoreTargets evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnForcePlayerIgnore",
    (SensorDevice_OnForcePlayerIgnore x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnForcePlayerIgnore(
    SensorDevice self,
    ForceIgnoreTargets? evt
);

void SendReprimandInstructionToSecuritySystem() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "SendReprimandInstructionToSecuritySystem;",
    (SensorDevice_SendReprimandInstructionToSecuritySystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_SendReprimandInstructionToSecuritySystem(
    SensorDevice self
);

void ReevaluateTargets() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ReevaluateTargets;",
    (SensorDevice_ReevaluateTargets x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ReevaluateTargets(
    SensorDevice self
);

void RemoveAllTargets() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "RemoveAllTargets;",
    (SensorDevice_RemoveAllTargets x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_RemoveAllTargets(
    SensorDevice self
);

FocusForcedHighlightData? GetDefaultHighlight() overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "GetDefaultHighlight;",
    (SensorDevice_GetDefaultHighlight x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.FocusForcedHighlightData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_GetDefaultHighlight(
    SensorDevice self
);

EFocusOutlineType GetCurrentOutline() overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "GetCurrentOutline;",
    (SensorDevice_GetCurrentOutline x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EFocusOutlineType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_GetCurrentOutline(
    SensorDevice self
);

bool OnRevealStateChanged(RevealStateChangedEvent evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnRevealStateChanged",
    (SensorDevice_OnRevealStateChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnRevealStateChanged(
    SensorDevice self,
    RevealStateChangedEvent? evt
);

void TCSMeshToggle(bool isVisible) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "TCSMeshToggle;Bool",
    (SensorDevice_TCSMeshToggle x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_TCSMeshToggle(
    SensorDevice self,
    bool isVisible
);

bool OnTCSTakeOverControlActivate(TCSTakeOverControlActivate evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnTCSTakeOverControlActivate",
    (SensorDevice_OnTCSTakeOverControlActivate x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnTCSTakeOverControlActivate(
    SensorDevice self,
    TCSTakeOverControlActivate? evt
);

bool OnTCSTakeOverControlDeactivate(TCSTakeOverControlDeactivate evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnTCSTakeOverControlDeactivate",
    (SensorDevice_OnTCSTakeOverControlDeactivate x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnTCSTakeOverControlDeactivate(
    SensorDevice self,
    TCSTakeOverControlDeactivate? evt
);

void SyncRotationWithAnimGraph() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "SyncRotationWithAnimGraph;",
    (SensorDevice_SyncRotationWithAnimGraph x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_SyncRotationWithAnimGraph(
    SensorDevice self
);

void ResetRotation() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ResetRotation;",
    (SensorDevice_ResetRotation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ResetRotation(
    SensorDevice self
);

EulerAngles GetRotationFromSlotRotation() RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "GetRotationFromSlotRotation;",
    (SensorDevice_GetRotationFromSlotRotation x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EulerAngles>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_GetRotationFromSlotRotation(
    SensorDevice self
);

bool OnTCSInputXYAxisEvent(TCSInputXYAxisEvent evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnTCSInputXYAxisEvent",
    (SensorDevice_OnTCSInputXYAxisEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnTCSInputXYAxisEvent(
    SensorDevice self,
    TCSInputXYAxisEvent? evt
);

void ForceLookAtQuestTarget() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ForceLookAtQuestTarget;",
    (SensorDevice_ForceLookAtQuestTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ForceLookAtQuestTarget(
    SensorDevice self
);

void InitializeDeviceFXRecord() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "InitializeDeviceFXRecord;",
    (SensorDevice_InitializeDeviceFXRecord x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_InitializeDeviceFXRecord(
    SensorDevice self
);

void InitializeLights() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "InitializeLights;",
    (SensorDevice_InitializeLights x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_InitializeLights(
    SensorDevice self
);

void InitializeLightsTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "InitializeLightsTask;ScriptTaskData",
    (SensorDevice_InitializeLightsTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void DetermineLightAttitudeRefs() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "DetermineLightAttitudeRefs;",
    (SensorDevice_DetermineLightAttitudeRefs x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_DetermineLightAttitudeRefs(
    SensorDevice self
);

void RunGameEffect(out game.EffectInstance effectInstance, game.EffectRef effectRef, CName slotName, float range) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "RunGameEffect;EffectInstanceEffectRefCNameFloat",
    (SensorDevice_RunGameEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_RunGameEffect(
    SensorDevice self,
    game.EffectInstance? effectInstance,
    game.EffectRef effectRef,
    CName slotName,
    float range
);

void TerminateGameEffect(out game.EffectInstance effectInstance) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "TerminateGameEffect;EffectInstance",
    (SensorDevice_TerminateGameEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_TerminateGameEffect(
    SensorDevice self,
    game.EffectInstance? effectInstance
);

void DetermineLightScanRefs(ScriptLightSettings desiredColor) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "DetermineLightScanRefs;ScriptLightSettings",
    (SensorDevice_DetermineLightScanRefs x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_DetermineLightScanRefs(
    SensorDevice self,
    ScriptLightSettings desiredColor
);

void DetermineLightInfoRefs(ScriptLightSettings desiredColor) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "DetermineLightInfoRefs;ScriptLightSettings",
    (SensorDevice_DetermineLightInfoRefs x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_DetermineLightInfoRefs(
    SensorDevice self,
    ScriptLightSettings desiredColor
);

void ToggleActiveEffect(bool active) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "ToggleActiveEffect;Bool",
    (SensorDevice_ToggleActiveEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_ToggleActiveEffect(
    SensorDevice self,
    bool active
);

bool OnReactoToPreventionSystem(ReactoToPreventionSystem evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnReactoToPreventionSystem",
    (SensorDevice_OnReactoToPreventionSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnReactoToPreventionSystem(
    SensorDevice self,
    ReactoToPreventionSystem? evt
);

bool HasEntityPlayerAttitudeGroup() RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "HasEntityPlayerAttitudeGroup;",
    (SensorDevice_HasEntityPlayerAttitudeGroup x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_HasEntityPlayerAttitudeGroup(
    SensorDevice self
);

bool OnProgramSetDeviceAttitude(ProgramSetDeviceAttitude evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnProgramSetDeviceAttitude",
    (SensorDevice_OnProgramSetDeviceAttitude x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnProgramSetDeviceAttitude(
    SensorDevice self,
    ProgramSetDeviceAttitude? evt
);

bool IsGameplayRelevant() overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "IsGameplayRelevant;",
    (SensorDevice_IsGameplayRelevant x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_IsGameplayRelevant(
    SensorDevice self
);

bool IsExplosive() overrideRTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "IsExplosive;",
    (SensorDevice_IsExplosive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_IsExplosive(
    SensorDevice self
);

bool OnNetworkLinkQuickhackEvent(NetworkLinkQuickhackEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "OnNetworkLinkQuickhackEvent",
    (SensorDevice_OnNetworkLinkQuickhackEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_OnNetworkLinkQuickhackEvent(
    SensorDevice self,
    NetworkLinkQuickhackEvent? evt
);

bool RemoveLinkedStatusEffects() RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "RemoveLinkedStatusEffects;",
    (SensorDevice_RemoveLinkedStatusEffects x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_RemoveLinkedStatusEffects(
    SensorDevice self
);

bool RemoveLinkedStatusEffectsFromTarget(ent.EntityID sourceID) RTTI

Generated hook

re.Hooks.Place(
    "SensorDevice",
    "RemoveLinkedStatusEffectsFromTarget;EntityID",
    (SensorDevice_RemoveLinkedStatusEffectsFromTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_RemoveLinkedStatusEffectsFromTarget(
    SensorDevice self,
    ent.EntityID sourceID
);

void RemoveLink() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "RemoveLink;",
    (SensorDevice_RemoveLink x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_RemoveLink(
    SensorDevice self
);

Target?[] GetTargets() RTTI

void SetSenseObjectType(game.data.SenseObjectType type) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "SetSenseObjectType;gamedataSenseObjectType",
    (SensorDevice_SetSenseObjectType x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_SetSenseObjectType(
    SensorDevice self,
    game.data.SenseObjectType type
);

void RunVisionConeGameEffect() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SensorDevice",
    "RunVisionConeGameEffect;",
    (SensorDevice_RunVisionConeGameEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SensorDevice_RunVisionConeGameEffect(
    SensorDevice self
);