class sense

Component

sense.Component

22 properties
113 functions

Extends ent.IPlacedComponent ent.IComponent IScriptable ISerializable

Properties

Property	Type	Offset
`enableBeingDetectable`	`bool`	`0x140`
`visibleObject`	`sense.VisibleObject?`	`0x130`
`sensorObject`	`sense.SensorObject?`	`0x120`
`isEnabled`	`bool`	`0x8B`
`forceDisableUI`	`bool`	`0x141`
`highLevelCb`	`red.CallbackObject?`	`0x0`	scripted
`reactionCb`	`red.CallbackObject?`	`0x10`	scripted
`wantedLevelChangedCb`	`red.CallbackObject?`	`0x20`	scripted
`highLevelState`	`game.data.NPCHighLevelState`	`0x30`	scripted
`mainPreset`	`TDBID`	`0x34`	scripted
`secondaryPreset`	`TDBID`	`0x3C`	scripted
`puppetBlackboard`	`WeakHandle<game.IBlackboard>`	`0x48`	scripted
`uiWantedBarBB`	`WeakHandle<game.IBlackboard>`	`0x58`	scripted
`hideUIElements`	`bool`	`0x68`	scripted
`enabledSenses`	`bool`	`0x69`	scripted
`shouldStartDetectingPlayerCached`	`bool`	`0x6A`	scripted
`wasPlayerLastReactionTarget`	`bool`	`0x6B`	scripted
`logSource`	`ESenseLogSource`	`0x6C`	scripted
`playerTakedownStateCallbackID`	`red.CallbackObject?`	`0x70`	scripted
`playerUpperBodyStateCallbackID`	`red.CallbackObject?`	`0x80`	scripted
`playerCarryingStateCallbackID`	`red.CallbackObject?`	`0x90`	scripted
`playerInPerception`	`WeakHandle<PlayerPuppet>`	`0xA0`	scripted

Functions

void SetHearingEnabled(bool enabled) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "SetHearingEnabled",
    (Component_SetHearingEnabled x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetHearingEnabled(
    sense.Component self,
    bool enabled
);

bool IsHearingEnabled() RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "IsHearingEnabled",
    (Component_IsHearingEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_IsHearingEnabled(
    sense.Component self
);

void SetCrowdsAggressiveState(bool isAggresive) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "SetCrowdsAggressiveState",
    (Component_SetCrowdsAggressiveState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetCrowdsAggressiveState(
    sense.Component self,
    bool isAggresive
);

bool IsAgentVisible(game.Object objectt) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "IsAgentVisible",
    (Component_IsAgentVisible x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_IsAgentVisible(
    sense.Component self,
    game.Object? objectt
);

float GetVisibilityTraceEndToAgentDist(game.Object objectt) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "GetVisibilityTraceEndToAgentDist",
    (Component_GetVisibilityTraceEndToAgentDist x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_GetVisibilityTraceEndToAgentDist(
    sense.Component self,
    game.Object? objectt
);

float GetDetection(ent.EntityID entityID) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "GetDetection",
    (Component_GetDetection x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_GetDetection(
    sense.Component self,
    ent.EntityID entityID
);

bool SetDetectionFactor(float detection, CName? shapeName) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "SetDetectionFactor",
    (Component_SetDetectionFactor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetDetectionFactor(
    sense.Component self,
    float detection,
    CName? shapeName
);

void SetDetectionCoolDown(float coolDown) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "SetDetectionCoolDown",
    (Component_SetDetectionCoolDown x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetDetectionCoolDown(
    sense.Component self,
    float coolDown
);

void SetDetectionDropFactor(float detectionDrop) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "SetDetectionDropFactor",
    (Component_SetDetectionDropFactor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetDetectionDropFactor(
    sense.Component self,
    float detectionDrop
);

bool SetDetectionMinRange(float range) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "SetDetectionMinRange",
    (Component_SetDetectionMinRange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetDetectionMinRange(
    sense.Component self,
    float range
);

bool UsePreset(TDBID presetID) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "UsePreset",
    (Component_UsePreset x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_UsePreset(
    sense.Component self,
    TDBID presetID
);

TDBID GetCurrentPreset() RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "GetCurrentPreset",
    (Component_GetCurrentPreset x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_GetCurrentPreset(
    sense.Component self
);

bool AddDetection(sense.Component target, float detection) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "AddDetection",
    (Component_AddDetection x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_AddDetection(
    sense.Component self,
    sense.Component? target,
    float detection
);

bool ResetDetection(ent.EntityID entityID) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "ResetDetection",
    (Component_ResetDetection x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_ResetDetection(
    sense.Component self,
    ent.EntityID entityID
);

sense.IShape?[] GetSenseShapes() RTTI

bool HasDetectionOverwrite(ent.EntityID entityID) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "HasDetectionOverwrite",
    (Component_HasDetectionOverwrite x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_HasDetectionOverwrite(
    sense.Component self,
    ent.EntityID entityID
);

void SetDetectionOverwrite(ent.EntityID entityID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "SetDetectionOverwrite",
    (Component_SetDetectionOverwrite x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetDetectionOverwrite(
    sense.Component self,
    ent.EntityID entityID
);

bool RemoveDetectionOverwrite(ent.EntityID entityID) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "RemoveDetectionOverwrite",
    (Component_RemoveDetectionOverwrite x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_RemoveDetectionOverwrite(
    sense.Component self,
    ent.EntityID entityID
);

bool HasDetectionAttitudeOverwrite(CName attitudeGroup) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "HasDetectionAttitudeOverwrite",
    (Component_HasDetectionAttitudeOverwrite x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_HasDetectionAttitudeOverwrite(
    sense.Component self,
    CName attitudeGroup
);

void SetDetectionAttitudeOverwrite(CName attitudeGroup) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "SetDetectionAttitudeOverwrite",
    (Component_SetDetectionAttitudeOverwrite x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetDetectionAttitudeOverwrite(
    sense.Component self,
    CName attitudeGroup
);

bool RemoveDetectionAttitudeOverwrite(CName attitudeGroup) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "RemoveDetectionAttitudeOverwrite",
    (Component_RemoveDetectionAttitudeOverwrite x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_RemoveDetectionAttitudeOverwrite(
    sense.Component self,
    CName attitudeGroup
);

float GetDetectionMultiplier(ent.EntityID entityID) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "GetDetectionMultiplier",
    (Component_GetDetectionMultiplier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_GetDetectionMultiplier(
    sense.Component self,
    ent.EntityID entityID
);

void SetDetectionMultiplier(ent.EntityID entityID, float multiplier) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "SetDetectionMultiplier",
    (Component_SetDetectionMultiplier x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetDetectionMultiplier(
    sense.Component self,
    ent.EntityID entityID,
    float multiplier
);

void CreateSenseMappin() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "CreateSenseMappin",
    (Component_CreateSenseMappin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_CreateSenseMappin(
    sense.Component self
);

void CreateHearingMappin() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "CreateHearingMappin",
    (Component_CreateHearingMappin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_CreateHearingMappin(
    sense.Component self
);

void RemoveSenseMappin() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "RemoveSenseMappin",
    (Component_RemoveSenseMappin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_RemoveSenseMappin(
    sense.Component self
);

void RequestRemovingSenseMappin() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "RequestRemovingSenseMappin",
    (Component_RequestRemovingSenseMappin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_RequestRemovingSenseMappin(
    sense.Component self
);

void RemoveHearingMappin() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "RemoveHearingMappin",
    (Component_RemoveHearingMappin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_RemoveHearingMappin(
    sense.Component self
);

void UpdateCrowdMappin() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "UpdateCrowdMappin",
    (Component_UpdateCrowdMappin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_UpdateCrowdMappin(
    sense.Component self
);

bool HasSenseMappin() RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "HasSenseMappin",
    (Component_HasSenseMappin x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_HasSenseMappin(
    sense.Component self
);

bool HasHearingMappin() RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "HasHearingMappin",
    (Component_HasHearingMappin x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_HasHearingMappin(
    sense.Component self
);

bool SetSensorObjectType(game.data.SenseObjectType objectType) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "SetSensorObjectType",
    (Component_SetSensorObjectType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetSensorObjectType(
    sense.Component self,
    game.data.SenseObjectType objectType
);

bool SetVisibleObjectType(game.data.SenseObjectType objectType) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "SetVisibleObjectType",
    (Component_SetVisibleObjectType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetVisibleObjectType(
    sense.Component self,
    game.data.SenseObjectType objectType
);

float GetTimeSinceLastEntityVisible(ent.EntityID entityID) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "GetTimeSinceLastEntityVisible",
    (Component_GetTimeSinceLastEntityVisible x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_GetTimeSinceLastEntityVisible(
    sense.Component self,
    ent.EntityID entityID
);

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

Generated hook

re.Hooks.Place(
    "senseComponent",
    "SetMainTrackedObject",
    (Component_SetMainTrackedObject x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool SetMainTrackedObjectTraceZOffset(sense.AdditionalTraceType traceType, float zOffset) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "SetMainTrackedObjectTraceZOffset",
    (Component_SetMainTrackedObjectTraceZOffset x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetMainTrackedObjectTraceZOffset(
    sense.Component self,
    sense.AdditionalTraceType traceType,
    float zOffset
);

float GetDistToTraceEndFromPosToMainTrackedObject(sense.AdditionalTraceType traceType) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "GetDistToTraceEndFromPosToMainTrackedObject",
    (Component_GetDistToTraceEndFromPosToMainTrackedObject x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_GetDistToTraceEndFromPosToMainTrackedObject(
    sense.Component self,
    sense.AdditionalTraceType traceType
);

bool SetForcedSensesTracing(game.data.SenseObjectType targetObjectType, EAIAttitude attitudeToTarget) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "SetForcedSensesTracing",
    (Component_SetForcedSensesTracing x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetForcedSensesTracing(
    sense.Component self,
    game.data.SenseObjectType targetObjectType,
    EAIAttitude attitudeToTarget
);

bool RemoveForcedSensesTracing(game.data.SenseObjectType targetObjectType, EAIAttitude attitudeToTarget) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "RemoveForcedSensesTracing",
    (Component_RemoveForcedSensesTracing x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_RemoveForcedSensesTracing(
    sense.Component self,
    game.data.SenseObjectType targetObjectType,
    EAIAttitude attitudeToTarget
);

bool SetTickDistanceOverride(float overrideDistance) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "SetTickDistanceOverride",
    (Component_SetTickDistanceOverride x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetTickDistanceOverride(
    sense.Component self,
    float overrideDistance
);

bool SetHasPierceableWapon(bool hasTechWeapon) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "SetHasPierceableWapon",
    (Component_SetHasPierceableWapon x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetHasPierceableWapon(
    sense.Component self,
    bool hasTechWeapon
);

void IgnoreLODChange(bool ignoreLOD) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "IgnoreLODChange",
    (Component_IgnoreLODChange x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_IgnoreLODChange(
    sense.Component self,
    bool ignoreLOD
);

bool SetVisionBlockersIgnoredBySensor(sense.VisionBlockerTypeFlags ignoredVisionBlockers) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "SetVisionBlockersIgnoredBySensor",
    (Component_SetVisionBlockersIgnoredBySensor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetVisionBlockersIgnoredBySensor(
    sense.Component self,
    sense.VisionBlockerTypeFlags ignoredVisionBlockers
);

void SetIsPlayerInterestingFromSecuritySystemPOV(bool isPlayerInteresting) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "SetIsPlayerInterestingFromSecuritySystemPOV",
    (Component_SetIsPlayerInterestingFromSecuritySystemPOV x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetIsPlayerInterestingFromSecuritySystemPOV(
    sense.Component self,
    bool isPlayerInteresting
);

bool LogEnabled() RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "LogEnabled;",
    (Component_LogEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_LogEnabled(
    sense.Component self
);

void Log(CName category, string message) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "Log;CNameString",
    (Component_Log x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_Log(
    sense.Component self,
    CName category,
    string message
);

void LogBySource(CName category, string message) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "LogBySource;CNameString",
    (Component_LogBySource x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_LogBySource(
    sense.Component self,
    CName category,
    string message
);

CName LogCategory(string suffix) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "LogCategory;String",
    (Component_LogCategory x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_LogCategory(
    sense.Component self,
    string suffix
);

void LogStart(ESenseLogSource source, string message) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "LogStart;ESenseLogSourceString",
    (Component_LogStart x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_LogStart(
    sense.Component self,
    ESenseLogSource source,
    string message
);

void LogInfo(string message) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "LogInfo;String",
    (Component_LogInfo x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_LogInfo(
    sense.Component self,
    string message
);

void LogTrueFalse(string message, bool value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "LogTrueFalse;StringBool",
    (Component_LogTrueFalse x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_LogTrueFalse(
    sense.Component self,
    string message,
    bool value
);

void ToggleComponent(bool condition) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "ToggleComponent;Bool",
    (Component_ToggleComponent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_ToggleComponent(
    sense.Component self,
    bool condition
);

void ToggleSenses(bool condition) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "ToggleSenses;Bool",
    (Component_ToggleSenses x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_ToggleSenses(
    sense.Component self,
    bool condition
);

game.Object? GetOwner() RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "GetOwner;",
    (Component_GetOwner x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_GetOwner(
    sense.Component self
);

SensorDevice? GetOwnerDevice() RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "GetOwnerDevice;",
    (Component_GetOwnerDevice x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.SensorDevice>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_GetOwnerDevice(
    sense.Component self
);

ScriptedPuppet? GetOwnerPuppet() RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "GetOwnerPuppet;",
    (Component_GetOwnerPuppet x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ScriptedPuppet>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_GetOwnerPuppet(
    sense.Component self
);

ScriptedPuppet? GetConstOwnerPuppet() RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "GetConstOwnerPuppet;",
    (Component_GetConstOwnerPuppet x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ScriptedPuppet>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_GetConstOwnerPuppet(
    sense.Component self
);

bool TryCreateSenseMappin() RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "TryCreateSenseMappin;",
    (Component_TryCreateSenseMappin x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_TryCreateSenseMappin(
    sense.Component self
);

bool OnSensePresetChangeEvent(sense.PresetChangeEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "OnSensePresetChangeEvent",
    (Component_OnSensePresetChangeEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnSensePresetChangeEvent(
    sense.Component self,
    sense.PresetChangeEvent? evt
);

bool OnSenseInitialize(sense.InitializeEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "OnSenseInitialize",
    (Component_OnSenseInitialize x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnSenseInitialize(
    sense.Component self,
    sense.InitializeEvent? evt
);

void OnDetach() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "OnDetach;",
    (Component_OnDetach x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnDetach(
    sense.Component self
);

bool OnHighLevelChanged(int value) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "OnHighLevelChanged",
    (Component_OnHighLevelChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnHighLevelChanged(
    sense.Component self,
    int value
);

bool OnCurrentWantedLevelChanged(int value) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "OnCurrentWantedLevelChanged",
    (Component_OnCurrentWantedLevelChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnCurrentWantedLevelChanged(
    sense.Component self,
    int value
);

bool OnDeath(game.events.DeathEvent evt) RTTI

Generated hook

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

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

bool OnDefeated(game.events.DefeatedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "OnDefeated",
    (Component_OnDefeated x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnDefeated(
    sense.Component self,
    game.events.DefeatedEvent? evt
);

bool OnResurrect(game.events.ResurrectEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "OnResurrect",
    (Component_OnResurrect x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnResurrect(
    sense.Component self,
    game.events.ResurrectEvent? evt
);

bool OnReactionChanged(int value) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "OnReactionChanged",
    (Component_OnReactionChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnReactionChanged(
    sense.Component self,
    int value
);

bool OnTargetAssessmentRequest(TargetAssessmentRequest evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Component_OnTargetAssessmentRequest(
    sense.Component self,
    TargetAssessmentRequest? evt
);

bool OnSenseEnabledEvent(sense.EnabledEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "OnSenseEnabledEvent",
    (Component_OnSenseEnabledEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnSenseEnabledEvent(
    sense.Component self,
    sense.EnabledEvent? evt
);

bool OnSenseVisibilityEvent(sense.VisibilityEvent evt) RTTI

Generated hook

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

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

bool OnAddToBlacklistEvent(AddToBlacklistEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "OnAddToBlacklistEvent",
    (Component_OnAddToBlacklistEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnAddToBlacklistEvent(
    sense.Component self,
    AddToBlacklistEvent? evt
);

bool OnRemoveFromBlacklistEvent(RemoveFromBlacklistEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "OnRemoveFromBlacklistEvent",
    (Component_OnRemoveFromBlacklistEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnRemoveFromBlacklistEvent(
    sense.Component self,
    RemoveFromBlacklistEvent? evt
);

void PlayerEnteredPerception(WeakHandle<PlayerPuppet> player) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "PlayerEnteredPerception;PlayerPuppet",
    (Component_PlayerEnteredPerception x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_PlayerEnteredPerception(
    sense.Component self,
    WeakHandle<PlayerPuppet> player
);

void PlayerExitedPercpetion(WeakHandle<PlayerPuppet> player) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "PlayerExitedPercpetion;PlayerPuppet",
    (Component_PlayerExitedPercpetion x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_PlayerExitedPercpetion(
    sense.Component self,
    WeakHandle<PlayerPuppet> player
);

void OnPlayerTakedownStateChange(int takedownState) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "OnPlayerTakedownStateChange;Int32",
    (Component_OnPlayerTakedownStateChange x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnPlayerTakedownStateChange(
    sense.Component self,
    int takedownState
);

void OnPlayerUpperBodyStateChange(int upperBodyState) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "OnPlayerUpperBodyStateChange;Int32",
    (Component_OnPlayerUpperBodyStateChange x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnPlayerUpperBodyStateChange(
    sense.Component self,
    int upperBodyState
);

void OnPlayerCarryingStateChange(bool carrying) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "OnPlayerCarryingStateChange;Bool",
    (Component_OnPlayerCarryingStateChange x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnPlayerCarryingStateChange(
    sense.Component self,
    bool carrying
);

bool OnDetectedEvent(sense.OnDetectedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "OnDetectedEvent",
    (Component_OnDetectedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool OnDetectionReachedZero(sense.OnRemoveDetection evt) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "OnDetectionReachedZero",
    (Component_OnDetectionReachedZero x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool OnAttitudeChanged(game.events.AttitudeChangedEvent evt) RTTI

Generated hook

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

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

bool OnAttitudeGroupChanged(game.events.AttitudeGroupChangedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "OnAttitudeGroupChanged",
    (Component_OnAttitudeGroupChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnAttitudeGroupChanged(
    sense.Component self,
    game.events.AttitudeGroupChangedEvent? evt
);

bool OnSuspiciousObjectEvent(AIbehaviorSuspiciousObjectEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "OnSuspiciousObjectEvent",
    (Component_OnSuspiciousObjectEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnSuspiciousObjectEvent(
    sense.Component self,
    AIbehaviorSuspiciousObjectEvent? evt
);

bool OnStatusEffectApplied(game.events.ApplyStatusEffectEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "OnStatusEffectApplied",
    (Component_OnStatusEffectApplied x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnStatusEffectApplied(
    sense.Component self,
    game.events.ApplyStatusEffectEvent? evt
);

bool OnSecurityAreaCrossingPerimeter(SecurityAreaCrossingPerimeter evt) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "OnSecurityAreaCrossingPerimeter",
    (Component_OnSecurityAreaCrossingPerimeter x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnSecurityAreaCrossingPerimeter(
    sense.Component self,
    SecurityAreaCrossingPerimeter? evt
);

bool ReevaluatePlayerInterestFromSecuritySystemPOV() RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "ReevaluatePlayerInterestFromSecuritySystemPOV;",
    (Component_ReevaluatePlayerInterestFromSecuritySystemPOV x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_ReevaluatePlayerInterestFromSecuritySystemPOV(
    sense.Component self
);

bool OnReevaluateDetectionOverwriteEvent(ReevaluateDetectionOverwriteEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "OnReevaluateDetectionOverwriteEvent",
    (Component_OnReevaluateDetectionOverwriteEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnReevaluateDetectionOverwriteEvent(
    sense.Component self,
    ReevaluateDetectionOverwriteEvent? evt
);

bool OnSensorOwnerChangedEvent(sense.SensorOwnerChangedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "OnSensorOwnerChangedEvent",
    (Component_OnSensorOwnerChangedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnSensorOwnerChangedEvent(
    sense.Component self,
    sense.SensorOwnerChangedEvent? evt
);

void UpdateVisionBlockersIgnoredBySensor() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "UpdateVisionBlockersIgnoredBySensor;",
    (Component_UpdateVisionBlockersIgnoredBySensor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_UpdateVisionBlockersIgnoredBySensor(
    sense.Component self
);

ScriptGameInstance GetGame() RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "GetGame;",
    (Component_GetGame x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ScriptGameInstance>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_GetGame(
    sense.Component self
);

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

Generated hook

re.Hooks.Place(
    "senseComponent",
    "IsTargetPlayer;GameObject",
    (Component_IsTargetPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

SecuritySystemControllerPS? GetSecuritySystem() RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "GetSecuritySystem;",
    (Component_GetSecuritySystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.SecuritySystemControllerPS>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_GetSecuritySystem(
    sense.Component self
);

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

Generated hook

re.Hooks.Place(
    "senseComponent",
    "IsTargetInterestingForSecuritySystem;GameObject",
    (Component_IsTargetInterestingForSecuritySystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void RefreshCombatDetectionMultiplier(ScriptedPuppet target) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "RefreshCombatDetectionMultiplier;ScriptedPuppet",
    (Component_RefreshCombatDetectionMultiplier x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_RefreshCombatDetectionMultiplier(
    sense.Component self,
    ScriptedPuppet? target
);

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

Generated hook

re.Hooks.Place(
    "senseComponent",
    "IsTargetInteresting;GameObject",
    (Component_IsTargetInteresting x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

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

Generated hook

re.Hooks.Place(
    "senseComponent",
    "IsPlayerRecentlyDroppedThreat;GameObject",
    (Component_IsPlayerRecentlyDroppedThreat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool IsOwnerHostileTowardsPlayer() RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "IsOwnerHostileTowardsPlayer;",
    (Component_IsOwnerHostileTowardsPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_IsOwnerHostileTowardsPlayer(
    sense.Component self
);

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

Generated hook

re.Hooks.Place(
    "senseComponent",
    "IsOwnerHostileTowardsTarget;GameObject",
    (Component_IsOwnerHostileTowardsTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool IsOwnerFriendlyTowardsPlayer() RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "IsOwnerFriendlyTowardsPlayer;",
    (Component_IsOwnerFriendlyTowardsPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_IsOwnerFriendlyTowardsPlayer(
    sense.Component self
);

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

Generated hook

re.Hooks.Place(
    "senseComponent",
    "IsOwnerFriendlyTowardsTarget;GameObject",
    (Component_IsOwnerFriendlyTowardsTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void InitDetectionOverwrite() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "InitDetectionOverwrite;",
    (Component_InitDetectionOverwrite x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_InitDetectionOverwrite(
    sense.Component self
);

bool ReevaluateDetectionOverwrite(WeakHandle<game.Object> target, bool? isVisible) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "ReevaluateDetectionOverwrite;GameObjectBool",
    (Component_ReevaluateDetectionOverwrite x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_ReevaluateDetectionOverwrite(
    sense.Component self,
    WeakHandle<game.Object> target,
    bool? isVisible
);

bool ShouldStartDetecting(game.Object target) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "ShouldStartDetecting;GameObject",
    (Component_ShouldStartDetecting x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_ShouldStartDetecting(
    sense.Component self,
    game.Object? target
);

bool ShouldStartDetectingPlayer(PlayerPuppet player) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "ShouldStartDetectingPlayer;PlayerPuppet",
    (Component_ShouldStartDetectingPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_ShouldStartDetectingPlayer(
    sense.Component self,
    PlayerPuppet? player
);

bool GetShouldStartDetectingPlayerCached() RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "GetShouldStartDetectingPlayerCached;",
    (Component_GetShouldStartDetectingPlayerCached x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_GetShouldStartDetectingPlayerCached(
    sense.Component self
);

void SendDetectionRiseEvent(WeakHandle<game.Object> target, bool isVisible) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "SendDetectionRiseEvent;GameObjectBool",
    (Component_SendDetectionRiseEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SendDetectionRiseEvent(
    sense.Component self,
    WeakHandle<game.Object> target,
    bool isVisible
);

bool OnHACK_UseSensePresetEvent(game.HACK_UseSensePresetEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "senseComponent",
    "OnHACK_UseSensePresetEvent",
    (Component_OnHACK_UseSensePresetEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_OnHACK_UseSensePresetEvent(
    sense.Component self,
    game.HACK_UseSensePresetEvent? evt
);

static void RequestSecondaryPresetChange(WeakHandle<game.Object> obj, string presetName) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "senseComponent::RequestSecondaryPresetChange;GameObjectscript_ref<String>",
    (Component_RequestSecondaryPresetChange x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_RequestSecondaryPresetChange(
    WeakHandle<game.Object> obj,
    string presetName
);

static void RequestDetectionOverwriteReevaluation(WeakHandle<game.Object> obj, WeakHandle<ent.Entity> target, float delay)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "senseComponent::RequestDetectionOverwriteReevaluation;GameObjectEntityFloat",
    (Component_RequestDetectionOverwriteReevaluation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_RequestDetectionOverwriteReevaluation(
    WeakHandle<game.Object> obj,
    WeakHandle<ent.Entity> target,
    float delay
);

static void RequestPresetChange(WeakHandle<game.Object> obj, TDBID presetID, bool mainPreset) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "senseComponent::RequestPresetChange;GameObjectTweakDBIDBool",
    (Component_RequestPresetChange x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_RequestPresetChange(
    WeakHandle<game.Object> obj,
    TDBID presetID,
    bool mainPreset
);

static void RequestSecondaryPresetChange(WeakHandle<game.Object> obj, TDBID presetID) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "senseComponent::RequestSecondaryPresetChange;GameObjectTweakDBID",
    (Component_RequestSecondaryPresetChange2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_RequestSecondaryPresetChange2(
    WeakHandle<game.Object> obj,
    TDBID presetID
);

static void ResetPreset(WeakHandle<game.Object> obj) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "senseComponent::ResetPreset;GameObject",
    (Component_ResetPreset x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_ResetPreset(
    WeakHandle<game.Object> obj
);

static void RequestMainPresetChange(WeakHandle<game.Object> obj, string presetName) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "senseComponent",
    "senseComponent::RequestMainPresetChange;GameObjectscript_ref<String>",
    (Component_RequestMainPresetChange x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_RequestMainPresetChange(
    WeakHandle<game.Object> obj,
    string presetName
);

static bool ShouldIgnoreIfPlayerCompanion(WeakHandle<ent.Entity> owner, WeakHandle<ent.Entity> target) staticRTTI global

Generated hook

re.Hooks.Place(
    "senseComponent",
    "senseComponent::ShouldIgnoreIfPlayerCompanion;EntityEntity",
    (Component_ShouldIgnoreIfPlayerCompanion x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_ShouldIgnoreIfPlayerCompanion(
    WeakHandle<ent.Entity> owner,
    WeakHandle<ent.Entity> target
);