class

ReactionManagerComponent

86 properties
274 functions

Extends game.ScriptableComponent game.Component ent.IComponent IScriptable ISerializable

Properties

Property	Type	Offset
`activeReaction`	`AIReactionData?`	`0x0`	scripted
`desiredReaction`	`AIReactionData?`	`0x10`	scripted
`stimuliCache`	`StimEventTaskData?[]`	`0x20`	scripted
`reactionCache`	`AIReactionData?[]`	`0x30`	scripted
`reactionPreset`	`game.data.ReactionPreset_Record?`	`0x40`	scripted
`puppetReactionBlackboard`	`game.IBlackboard?`	`0x50`	scripted
`receivedStimType`	`game.data.StimType`	`0x60`	scripted
`receivedStimPropagation`	`game.data.StimPropagation`	`0x64`	scripted
`inCrowd`	`bool`	`0x68`	scripted
`inTrafficLane`	`bool`	`0x69`	scripted
`desiredFearPhase`	`int`	`0x6C`	scripted
`previousFearPhase`	`int`	`0x70`	scripted
`NPCRadius`	`float`	`0x74`	scripted
`bumpTriggerDistanceBufferMounted`	`float`	`0x78`	scripted
`bumpTriggerDistanceBufferCrouched`	`float`	`0x7C`	scripted
`delayReactionEventID`	`game.DelayID`	`0x80`	scripted
`delay`	`Vector2`	`0x88`	scripted
`delayDetectionEventID`	`game.DelayID`	`0x90`	scripted
`delayStimEventID`	`game.DelayID`	`0x98`	scripted
`resetReactionDataID`	`game.DelayID`	`0xA0`	scripted
`callingPoliceID`	`game.DelayID`	`0xA8`	scripted
`lookatEvent`	`ent.LookAtAddEvent?`	`0xB0`	scripted
`ignoreList`	`ent.EntityID[]`	`0xC0`	scripted
`investigationList`	`StimEventData[]`	`0xD0`	scripted
`pendingReaction`	`AIReactionData?`	`0xE0`	scripted
`ovefloodCooldown`	`float`	`0xF0`	scripted
`stanceState`	`game.data.NPCStanceState`	`0xF4`	scripted
`highLevelState`	`game.data.NPCHighLevelState`	`0xF8`	scripted
`aiRole`	`EAIRole`	`0xFC`	scripted
`pendingBehaviorCb`	`red.CallbackObject?`	`0x100`	scripted
`inPendingBehavior`	`bool`	`0x110`	scripted
`cacheSecuritySysOutput`	`SecuritySystemOutput?`	`0x118`	scripted
`environmentalHazards`	`sense.StimuliEvent?[]`	`0x128`	scripted
`environmentalHazardsDelayIDs`	`game.DelayID[]`	`0x138`	scripted
`stolenVehicle`	`WeakHandle<vehicle.BaseObject>`	`0x148`	scripted
`isAlertedByDeadBody`	`bool`	`0x158`	scripted
`isInCrosswalk`	`bool`	`0x159`	scripted
`beignHijacked`	`bool`	`0x15A`	scripted
`owner_id`	`ent.EntityID`	`0x160`	scripted
`presetName`	`CName`	`0x168`	scripted
`updateByActive`	`bool`	`0x170`	scripted
`personalities`	`game.data.StatType[]`	`0x178`	scripted
`workspotReactionPlayed`	`bool`	`0x188`	scripted
`inReactionSequence`	`bool`	`0x189`	scripted
`playerProximity`	`bool`	`0x18A`	scripted
`fearToIdleDistance`	`Vector2`	`0x18C`	scripted
`exitWorkspotAim`	`Vector2`	`0x194`	scripted
`bumpedRecently`	`int`	`0x19C`	scripted
`bumpTimestamp`	`float`	`0x1A0`	scripted
`crowdAimingReactionDistance`	`float`	`0x1A4`	scripted
`fearInPlaceAroundDistance`	`float`	`0x1A8`	scripted
`lookatRepeat`	`bool`	`0x1AC`	scripted
`disturbingComfortZoneInProgress`	`bool`	`0x1AD`	scripted
`entereProximityRecently`	`int`	`0x1B0`	scripted
`comfortZoneTimestamp`	`float`	`0x1B4`	scripted
`disturbComfortZoneEventId`	`game.DelayID`	`0x1B8`	scripted
`checkComfortZoneEventId`	`game.DelayID`	`0x1C0`	scripted
`spreadingFearEventId`	`game.DelayID`	`0x1C8`	scripted
`proximityLookatEventId`	`game.DelayID`	`0x1D0`	scripted
`resetFacialEventId`	`game.DelayID`	`0x1D8`	scripted
`exitWorkspotSequenceEventId`	`game.DelayID`	`0x1E0`	scripted
`exitFearInVehicleEventId`	`game.DelayID`	`0x1E8`	scripted
`fastWalk`	`bool`	`0x1F0`	scripted
`createThreshold`	`bool`	`0x1F1`	scripted
`initialized`	`bool`	`0x1F2`	scripted
`initCrowd`	`bool`	`0x1F3`	scripted
`facialCooldown`	`float`	`0x1F4`	scripted
`disturbComfortZoneAggressiveEventId`	`game.DelayID`	`0x1F8`	scripted
`backOffInProgress`	`bool`	`0x200`	scripted
`backOffTimestamp`	`float`	`0x204`	scripted
`crowdFearStage`	`game.FearStage`	`0x208`	scripted
`fearLocomotionWrapper`	`bool`	`0x209`	scripted
`successfulFearDeescalation`	`float`	`0x20C`	scripted
`willingToCallPolice`	`bool`	`0x210`	scripted
`deadBodyInvestigators`	`ent.EntityID[]`	`0x218`	scripted
`deadBodyStartingPosition`	`Vector4`	`0x230`	scripted
`currentStimThresholdValue`	`int`	`0x240`	scripted
`timeStampThreshold`	`float`	`0x244`	scripted
`currentStealthStimThresholdValue`	`int`	`0x248`	scripted
`stealthTimeStampThreshold`	`float`	`0x24C`	scripted
`driverAllowedToGetAggressive`	`bool`	`0x250`	scripted
`driverIsAggressive`	`bool`	`0x251`	scripted
`logSource`	`EReactLogSource`	`0x252`	scripted
`gracePeriodDuration`	`float`	`0x258`	scripted
`recentAlertObject`	`WeakHandle<game.Object>`	`0x260`	scripted
`recentAlertTimeStamp`	`float`	`0x270`	scripted

Functions

bool LogEnabled() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_LogEnabled(
    ReactionManagerComponent self
);

void Log(CName category, string message) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_Log(
    ReactionManagerComponent self,
    CName category,
    string message
);

void LogStim(CName category, game.data.StimType stimType, game.data.StimPropagation stimPropagation, string message) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "LogStim;CNamegamedataStimTypegamedataStimPropagationString",
    (ReactionManagerComponent_LogStim x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_LogStim(
    ReactionManagerComponent self,
    CName category,
    game.data.StimType stimType,
    game.data.StimPropagation stimPropagation,
    string message
);

void LogReactionData(CName category, AIReactionData reactionData, string message) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "LogReactionData;CNameAIReactionDataString",
    (ReactionManagerComponent_LogReactionData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_LogReactionData(
    ReactionManagerComponent self,
    CName category,
    AIReactionData? reactionData,
    string message
);

void LogReaction(CName category, string message) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "LogReaction;CNameString",
    (ReactionManagerComponent_LogReaction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_LogReaction(
    ReactionManagerComponent self,
    CName category,
    string message
);

CName LogCategory(string suffix) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_LogCategory(
    ReactionManagerComponent self,
    string suffix
);

void LogStart(EReactLogSource source, string message) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "LogStart;EReactLogSourceString",
    (ReactionManagerComponent_LogStart x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_LogStart(
    ReactionManagerComponent self,
    EReactLogSource source,
    string message
);

void LogInfo(string message) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_LogInfo(
    ReactionManagerComponent self,
    string message
);

void LogSuccess(string message) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "LogSuccess;String",
    (ReactionManagerComponent_LogSuccess x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_LogSuccess(
    ReactionManagerComponent self,
    string message
);

void LogFailure(string message) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "LogFailure;String",
    (ReactionManagerComponent_LogFailure x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_LogFailure(
    ReactionManagerComponent self,
    string message
);

void HandleStimEventByTask(sense.StimuliEvent stimEvent, bool? delayed) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "HandleStimEventByTask;StimuliEventBool",
    (ReactionManagerComponent_HandleStimEventByTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_HandleStimEventByTask(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent,
    bool? delayed
);

void HandleStimEventTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "HandleStimEventTask;ScriptTaskData",
    (ReactionManagerComponent_HandleStimEventTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void HandleStimEvent(StimEventTaskData stimData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "HandleStimEvent;StimEventTaskData",
    (ReactionManagerComponent_HandleStimEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_HandleStimEvent(
    ReactionManagerComponent self,
    StimEventTaskData? stimData
);

void ReactToSecuritySystemOutputByTask(SecuritySystemOutput evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "ReactToSecuritySystemOutputByTask;SecuritySystemOutput",
    (ReactionManagerComponent_ReactToSecuritySystemOutputByTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void ReactToSecuritySystemOutputTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "ReactToSecuritySystemOutputTask;ScriptTaskData",
    (ReactionManagerComponent_ReactToSecuritySystemOutputTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void OnGameAttach() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "OnGameAttach;",
    (ReactionManagerComponent_OnGameAttach x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnGameAttach(
    ReactionManagerComponent self
);

bool OnPlayerMuntedToMyVehicle(PlayerMuntedToMyVehicle evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnPlayerMuntedToMyVehicle",
    (ReactionManagerComponent_OnPlayerMuntedToMyVehicle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnPlayerMuntedToMyVehicle(
    ReactionManagerComponent self,
    PlayerMuntedToMyVehicle? evt
);

bool OnSenseVisibilityEvent(sense.VisibilityEvent evt) RTTI

Generated hook

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

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

bool OnLookedAtEvent(LookedAtEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnLookedAtEvent",
    (ReactionManagerComponent_OnLookedAtEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnLookedAtEvent(
    ReactionManagerComponent self,
    LookedAtEvent? evt
);

bool OnDetectedEvent(sense.OnDetectedEvent evt) RTTI

Generated hook

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

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

bool OnSecurityAreaCrossingPerimeter(SecurityAreaCrossingPerimeter evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnSecurityAreaCrossingPerimeter(
    ReactionManagerComponent self,
    SecurityAreaCrossingPerimeter? evt
);

bool OnSecuritySystemOutput(SecuritySystemOutput evt) RTTI

Generated hook

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

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

bool OnReprimandEscalationEvent(ReprimandEscalationEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnReprimandEscalationEvent",
    (ReactionManagerComponent_OnReprimandEscalationEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnReprimandEscalationEvent(
    ReactionManagerComponent self,
    ReprimandEscalationEvent? evt
);

void StartEscalateReprimand() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "StartEscalateReprimand;",
    (ReactionManagerComponent_StartEscalateReprimand x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_StartEscalateReprimand(
    ReactionManagerComponent self
);

void ReprimandEscalation() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "ReprimandEscalation;",
    (ReactionManagerComponent_ReprimandEscalation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ReprimandEscalation(
    ReactionManagerComponent self
);

void DeescalateReprimand() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "DeescalateReprimand;",
    (ReactionManagerComponent_DeescalateReprimand x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_DeescalateReprimand(
    ReactionManagerComponent self
);

bool OnReprimandUpdate(ReprimandUpdate evt) RTTI

Generated hook

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

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

bool RecentReaction(game.data.Output behaviorName) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "RecentReaction;gamedataOutput",
    (ReactionManagerComponent_RecentReaction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_RecentReaction(
    ReactionManagerComponent self,
    game.data.Output behaviorName
);

bool OnSuspiciousObjectEvent(AIbehaviorSuspiciousObjectEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnSuspiciousObjectEvent(
    ReactionManagerComponent self,
    AIbehaviorSuspiciousObjectEvent? evt
);

WeakHandle<game.Object> GetCombatTarget(WeakHandle<game.Object> source, WeakHandle<ent.Entity>? attacker) RTTI

bool IsSourceGrenade(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsSourceGrenade;StimuliEvent",
    (ReactionManagerComponent_IsSourceGrenade x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsSourceGrenade(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

WeakHandle<game.Object> GetGrenadeInstigator(sense.StimuliEvent stimEvent) RTTI

void JoinSearchWithAlert(ScriptedPuppet ownerPuppet, WeakHandle<game.Object> target, float timeToLive) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "JoinSearchWithAlert;ScriptedPuppetGameObjectFloat",
    (ReactionManagerComponent_JoinSearchWithAlert x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_JoinSearchWithAlert(
    ReactionManagerComponent self,
    ScriptedPuppet? ownerPuppet,
    WeakHandle<game.Object> target,
    float timeToLive
);

void HelpAllyWithAlert(ScriptedPuppet ownerPuppet, WeakHandle<game.Object> target, float timeToLive) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "HelpAllyWithAlert;ScriptedPuppetGameObjectFloat",
    (ReactionManagerComponent_HelpAllyWithAlert x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_HelpAllyWithAlert(
    ReactionManagerComponent self,
    ScriptedPuppet? ownerPuppet,
    WeakHandle<game.Object> target,
    float timeToLive
);

void HelpAlly(WeakHandle<game.Object> ally, WeakHandle<game.Object> targetOfAlly, bool onlyAlertNoThreat, bool? dontTrySquad)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "HelpAlly;GameObjectGameObjectBoolBool",
    (ReactionManagerComponent_HelpAlly x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_HelpAlly(
    ReactionManagerComponent self,
    WeakHandle<game.Object> ally,
    WeakHandle<game.Object> targetOfAlly,
    bool onlyAlertNoThreat,
    bool? dontTrySquad
);

void HelpPlayer(WeakHandle<game.Object> enemy) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "HelpPlayer;GameObject",
    (ReactionManagerComponent_HelpPlayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_HelpPlayer(
    ReactionManagerComponent self,
    WeakHandle<game.Object> enemy
);

void ReactToSecurityOutput(SecuritySystemOutput evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "ReactToSecurityOutput;SecuritySystemOutput",
    (ReactionManagerComponent_ReactToSecurityOutput x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool ReflectSecSysStateToHLS(ESecuritySystemState securityState) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ReflectSecSysStateToHLS;ESecuritySystemState",
    (ReactionManagerComponent_ReflectSecSysStateToHLS x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ReflectSecSysStateToHLS(
    ReactionManagerComponent self,
    ESecuritySystemState securityState
);

void TriggerAlerted(WeakHandle<game.Object>? instigator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "TriggerAlerted;GameObject",
    (ReactionManagerComponent_TriggerAlerted x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_TriggerAlerted(
    ReactionManagerComponent self,
    WeakHandle<game.Object>? instigator
);

void TriggerCombat(WeakHandle<game.Object> trespasser) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "TriggerCombat;GameObject",
    (ReactionManagerComponent_TriggerCombat x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_TriggerCombat(
    ReactionManagerComponent self,
    WeakHandle<game.Object> trespasser
);

bool OnReactionBehaviorStatus(ReactionBehaviorStatus evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnReactionBehaviorStatus",
    (ReactionManagerComponent_OnReactionBehaviorStatus x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnReactionBehaviorStatus(
    ReactionManagerComponent self,
    ReactionBehaviorStatus? evt
);

bool OnEndLookatEvent(EndLookatEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnEndLookatEvent",
    (ReactionManagerComponent_OnEndLookatEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnEndLookatEvent(
    ReactionManagerComponent self,
    EndLookatEvent? evt
);

bool OnDisableUndeadAnimFeatureEvent(DisableUndeadAnimFeatureEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnDisableUndeadAnimFeatureEvent",
    (ReactionManagerComponent_OnDisableUndeadAnimFeatureEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnDisableUndeadAnimFeatureEvent(
    ReactionManagerComponent self,
    DisableUndeadAnimFeatureEvent? evt
);

bool OnTerminateReactionLookatEvent(TerminateReactionLookatEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnTerminateReactionLookatEvent",
    (ReactionManagerComponent_OnTerminateReactionLookatEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnTerminateReactionLookatEvent(
    ReactionManagerComponent self,
    TerminateReactionLookatEvent? evt
);

bool OnRepeatLookatEvent(RepeatLookatEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnRepeatLookatEvent",
    (ReactionManagerComponent_OnRepeatLookatEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnRepeatLookatEvent(
    ReactionManagerComponent self,
    RepeatLookatEvent? evt
);

bool OnEventReceived(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnEventReceived",
    (ReactionManagerComponent_OnEventReceived x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnEventReceived(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool OnAIEvent(AIAIEvent aiEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnAIEvent",
    (ReactionManagerComponent_OnAIEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnAIEvent(
    ReactionManagerComponent self,
    AIAIEvent? aiEvent
);

void Initialiaze() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "Initialiaze;",
    (ReactionManagerComponent_Initialiaze x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_Initialiaze(
    ReactionManagerComponent self
);

void CacheEvent(StimEventTaskData stimData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "CacheEvent;StimEventTaskData",
    (ReactionManagerComponent_CacheEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_CacheEvent(
    ReactionManagerComponent self,
    StimEventTaskData? stimData
);

void CacheReaction(AIReactionData reactionData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "CacheReaction;AIReactionData",
    (ReactionManagerComponent_CacheReaction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_CacheReaction(
    ReactionManagerComponent self,
    AIReactionData? reactionData
);

bool IsEventDuplicated(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsEventDuplicated;StimuliEvent",
    (ReactionManagerComponent_IsEventDuplicated x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsEventDuplicated(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool IsDuplicate(sense.StimuliEvent stimEvent, sense.StimuliEvent cacheStim) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsDuplicate;StimuliEventStimuliEvent",
    (ReactionManagerComponent_IsDuplicate x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsDuplicate(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent,
    sense.StimuliEvent? cacheStim
);

bool OnStimThresholdEvent(StimThresholdEvent thresholdEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnStimThresholdEvent",
    (ReactionManagerComponent_OnStimThresholdEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnStimThresholdEvent(
    ReactionManagerComponent self,
    StimThresholdEvent? thresholdEvent
);

bool OnStealthStimThresholdEvent(StealthStimThresholdEvent thresholdEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnStealthStimThresholdEvent",
    (ReactionManagerComponent_OnStealthStimThresholdEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnStealthStimThresholdEvent(
    ReactionManagerComponent self,
    StealthStimThresholdEvent? thresholdEvent
);

ent.EntityID[] GetIgnoreList() RTTI

bool IsStimuliEventValid(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsStimuliEventValid;StimuliEvent",
    (ReactionManagerComponent_IsStimuliEventValid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsStimuliEventValid(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool ShouldEventBeProcessed(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ShouldEventBeProcessed;StimuliEvent",
    (ReactionManagerComponent_ShouldEventBeProcessed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ShouldEventBeProcessed(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool ShouldVisualStimBeProcessed(sense.StimuliEvent stimEvent, AIReactionData reactionData) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ShouldVisualStimBeProcessed;StimuliEventAIReactionData",
    (ReactionManagerComponent_ShouldVisualStimBeProcessed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ShouldVisualStimBeProcessed(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent,
    AIReactionData? reactionData
);

bool ShouldAudioStimBeProcessed(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ShouldAudioStimBeProcessed;StimuliEvent",
    (ReactionManagerComponent_ShouldAudioStimBeProcessed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ShouldAudioStimBeProcessed(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool ShouldFriendlyStimBeProcessed(sense.StimuliEvent stimEvent, sense.StimInvestigateData investigateData) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ShouldFriendlyStimBeProcessed;StimuliEventstimInvestigateData",
    (ReactionManagerComponent_ShouldFriendlyStimBeProcessed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ShouldFriendlyStimBeProcessed(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent,
    sense.StimInvestigateData investigateData
);

bool ShouldNeutralStimBeProcessed(sense.StimuliEvent stimEvent, sense.StimInvestigateData investigateData) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ShouldNeutralStimBeProcessed;StimuliEventstimInvestigateData",
    (ReactionManagerComponent_ShouldNeutralStimBeProcessed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ShouldNeutralStimBeProcessed(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent,
    sense.StimInvestigateData investigateData
);

bool ShouldHostileStimBeProcessed(sense.StimuliEvent stimEvent, sense.StimInvestigateData investigateData) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ShouldHostileStimBeProcessed;StimuliEventstimInvestigateData",
    (ReactionManagerComponent_ShouldHostileStimBeProcessed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ShouldHostileStimBeProcessed(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent,
    sense.StimInvestigateData investigateData
);

WeakHandle<game.Object> GetRealStimSource(sense.StimuliEvent stimEvent) RTTI

bool ShouldStimBeProcessed(sense.StimuliEvent stimEvent, bool delayed) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ShouldStimBeProcessed;StimuliEventBool",
    (ReactionManagerComponent_ShouldStimBeProcessed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ShouldStimBeProcessed(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent,
    bool delayed
);

StimParams ProcessStimParams(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ProcessStimParams;StimuliEvent",
    (ReactionManagerComponent_ProcessStimParams x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.StimParams>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ProcessStimParams(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

StimEventData FillStimData(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "FillStimData;StimuliEvent",
    (ReactionManagerComponent_FillStimData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.StimEventData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_FillStimData(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool IsReactionAvailableInPreset(game.data.StimType stimTrigger) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsReactionAvailableInPreset;gamedataStimType",
    (ReactionManagerComponent_IsReactionAvailableInPreset x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsReactionAvailableInPreset(
    ReactionManagerComponent self,
    game.data.StimType stimTrigger
);

void CreateFearThreashold() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "CreateFearThreashold;",
    (ReactionManagerComponent_CreateFearThreashold x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_CreateFearThreashold(
    ReactionManagerComponent self
);

void AddReactionValueToStatPool(AIReactionData reactionData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "AddReactionValueToStatPool;AIReactionData",
    (ReactionManagerComponent_AddReactionValueToStatPool x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_AddReactionValueToStatPool(
    ReactionManagerComponent self,
    AIReactionData? reactionData
);

WeakHandle<game.data.Rule_Record>[] GetRules() RTTI

ReactionOutput GetReactionOutput(game.data.StimType stimType, WeakHandle<game.data.Rule_Record>[] rules) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetReactionOutput;gamedataStimTypescript_ref<array<Rule_Record>>",
    (ReactionManagerComponent_GetReactionOutput x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ReactionOutput>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetReactionOutput(
    ReactionManagerComponent self,
    game.data.StimType stimType,
    WeakHandle<game.data.Rule_Record>[] rules
);

bool StimRule(WeakHandle<game.data.Rule_Record> rule, game.data.StimType stimType) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "StimRule;Rule_RecordgamedataStimType",
    (ReactionManagerComponent_StimRule x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_StimRule(
    ReactionManagerComponent self,
    WeakHandle<game.data.Rule_Record> rule,
    game.data.StimType stimType
);

void ProcessReactionOutput(StimEventTaskData stimData, StimParams stimParams) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "ProcessReactionOutput;StimEventTaskDataStimParams",
    (ReactionManagerComponent_ProcessReactionOutput x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ProcessReactionOutput(
    ReactionManagerComponent self,
    StimEventTaskData? stimData,
    StimParams stimParams
);

void UpdateActiveReaction(ReactionOutput reaction, sense.StimuliEvent stimEvent, StimEventData stimData, bool updateByActive)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "UpdateActiveReaction;ReactionOutputStimuliEventStimEventDataBool",
    (ReactionManagerComponent_UpdateActiveReaction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_UpdateActiveReaction(
    ReactionManagerComponent self,
    ReactionOutput reaction,
    sense.StimuliEvent? stimEvent,
    StimEventData stimData,
    bool updateByActive
);

void UpdateStimSource() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "UpdateStimSource;",
    (ReactionManagerComponent_UpdateStimSource x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_UpdateStimSource(
    ReactionManagerComponent self
);

void TriggerBehaviorReaction(ReactionOutput reaction, StimEventTaskData stimTaskData, StimEventData stimData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "TriggerBehaviorReaction;ReactionOutputStimEventTaskDataStimEventData",
    (ReactionManagerComponent_TriggerBehaviorReaction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_TriggerBehaviorReaction(
    ReactionManagerComponent self,
    ReactionOutput reaction,
    StimEventTaskData? stimTaskData,
    StimEventData stimData
);

Vector4 GetStimSource(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetStimSource;StimuliEvent",
    (ReactionManagerComponent_GetStimSource x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetStimSource(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool TryTriggerCombatOrAlertedFromHostileStim(sense.StimuliEvent stimEvent, StimEventTaskData stimData, AIReactionData reactionData, game.Object instigator)

RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "TryTriggerCombatOrAlertedFromHostileStim;StimuliEventStimEventTaskDataAIReactionDataGameObject",
    (ReactionManagerComponent_TryTriggerCombatOrAlertedFromHostileStim x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_TryTriggerCombatOrAlertedFromHostileStim(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent,
    StimEventTaskData? stimData,
    AIReactionData? reactionData,
    game.Object? instigator
);

bool CanTriggerCombatFromHostileStim(sense.StimuliEvent stimEvent, AIReactionData reactionData) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "CanTriggerCombatFromHostileStim;StimuliEventAIReactionData",
    (ReactionManagerComponent_CanTriggerCombatFromHostileStim x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_CanTriggerCombatFromHostileStim(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent,
    AIReactionData? reactionData
);

bool CanTriggerAlertedFromHostileStim(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "CanTriggerAlertedFromHostileStim;StimuliEvent",
    (ReactionManagerComponent_CanTriggerAlertedFromHostileStim x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_CanTriggerAlertedFromHostileStim(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool ShouldIgnoreCombatStim(game.data.StimType stimType, WeakHandle<ScriptedPuppet> instigator, WeakHandle<ScriptedPuppet> source, Vector4 sourcePos, bool? log)

RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ShouldIgnoreCombatStim;gamedataStimTypeScriptedPuppetScriptedPuppetVector4Bool",
    (ReactionManagerComponent_ShouldIgnoreCombatStim x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ShouldIgnoreCombatStim(
    ReactionManagerComponent self,
    game.data.StimType stimType,
    WeakHandle<ScriptedPuppet> instigator,
    WeakHandle<ScriptedPuppet> source,
    Vector4 sourcePos,
    bool? log
);

bool ShouldIgnoreCombatStim(game.data.StimType stimType, WeakHandle<ScriptedPuppet> instigator, WeakHandle<ScriptedPuppet> source, Vector4 sourcePos, bool canDelay, out bool canIgnoreOnlyDueToDelay, out bool canIgnorePlayerCombatStim, bool log)

RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ShouldIgnoreCombatStim;gamedataStimTypeScriptedPuppetScriptedPuppetVector4BoolBoolBoolBool",
    (ReactionManagerComponent_ShouldIgnoreCombatStim2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ShouldIgnoreCombatStim2(
    ReactionManagerComponent self,
    game.data.StimType stimType,
    WeakHandle<ScriptedPuppet> instigator,
    WeakHandle<ScriptedPuppet> source,
    Vector4 sourcePos,
    bool canDelay,
    bool canIgnoreOnlyDueToDelay,
    bool canIgnorePlayerCombatStim,
    bool log
);

bool IsSquadMateInDanger() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsSquadMateInDanger;",
    (ReactionManagerComponent_IsSquadMateInDanger x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsSquadMateInDanger(
    ReactionManagerComponent self
);

bool FirstSquadMemberReaction() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "FirstSquadMemberReaction;",
    (ReactionManagerComponent_FirstSquadMemberReaction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_FirstSquadMemberReaction(
    ReactionManagerComponent self
);

void ClearPendingReaction() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "ClearPendingReaction;",
    (ReactionManagerComponent_ClearPendingReaction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ClearPendingReaction(
    ReactionManagerComponent self
);

void TriggerPendingReaction() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "TriggerPendingReaction;",
    (ReactionManagerComponent_TriggerPendingReaction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_TriggerPendingReaction(
    ReactionManagerComponent self
);

void TriggerReactionBehaviorForCrowd(sense.StimuliEvent stimEvent, game.data.Output reaction, bool dontPlayStartUpAnimation, bool? skipInitialAnimation)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "TriggerReactionBehaviorForCrowd;StimuliEventgamedataOutputBoolBool",
    (ReactionManagerComponent_TriggerReactionBehaviorForCrowd x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_TriggerReactionBehaviorForCrowd(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent,
    game.data.Output reaction,
    bool dontPlayStartUpAnimation,
    bool? skipInitialAnimation
);

void TriggerReactionBehaviorForCrowd(game.Object target, game.data.Output reaction, bool initAnimInWorkspot, Vector4? sourcePosition)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "TriggerReactionBehaviorForCrowd;GameObjectgamedataOutputBoolVector4",
    (ReactionManagerComponent_TriggerReactionBehaviorForCrowd2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_TriggerReactionBehaviorForCrowd2(
    ReactionManagerComponent self,
    game.Object? target,
    game.data.Output reaction,
    bool initAnimInWorkspot,
    Vector4? sourcePosition
);

bool OnDelayStimEvent(DelayStimEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnDelayStimEvent",
    (ReactionManagerComponent_OnDelayStimEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnDelayStimEvent(
    ReactionManagerComponent self,
    DelayStimEvent? evt
);

void ProcessEnvironmentalHazard(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "ProcessEnvironmentalHazard;StimuliEvent",
    (ReactionManagerComponent_ProcessEnvironmentalHazard x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ProcessEnvironmentalHazard(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

game.DelayID DelayEnvironmentalHazardEvent(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "DelayEnvironmentalHazardEvent;StimuliEvent",
    (ReactionManagerComponent_DelayEnvironmentalHazardEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.DelayID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_DelayEnvironmentalHazardEvent(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool OnCleanEnvironmentalHazardEvent(CleanEnvironmentalHazardEvent cleanEnvironmentalHazardEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnCleanEnvironmentalHazardEvent",
    (ReactionManagerComponent_OnCleanEnvironmentalHazardEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnCleanEnvironmentalHazardEvent(
    ReactionManagerComponent self,
    CleanEnvironmentalHazardEvent? cleanEnvironmentalHazardEvent
);

void ProcessStimForTheDead(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "ProcessStimForTheDead;StimuliEvent",
    (ReactionManagerComponent_ProcessStimForTheDead x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ProcessStimForTheDead(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

void InitCrowd() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "InitCrowd;",
    (ReactionManagerComponent_InitCrowd x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_InitCrowd(
    ReactionManagerComponent self
);

bool ShouldStimBeProcessedByCrowd(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ShouldStimBeProcessedByCrowd;StimuliEvent",
    (ReactionManagerComponent_ShouldStimBeProcessedByCrowd x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ShouldStimBeProcessedByCrowd(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

void HandleCrowdReaction(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "HandleCrowdReaction;StimuliEvent",
    (ReactionManagerComponent_HandleCrowdReaction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_HandleCrowdReaction(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

void TriggerAggressiveCrowdBehavior(game.Object owner, game.Object target) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "TriggerAggressiveCrowdBehavior;GameObjectGameObject",
    (ReactionManagerComponent_TriggerAggressiveCrowdBehavior x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_TriggerAggressiveCrowdBehavior(
    ReactionManagerComponent self,
    game.Object? owner,
    game.Object? target
);

bool OnCrowdReaction(DelayedCrowdReactionEvent reactionDelayEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnCrowdReaction",
    (ReactionManagerComponent_OnCrowdReaction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnCrowdReaction(
    ReactionManagerComponent self,
    DelayedCrowdReactionEvent? reactionDelayEvent
);

void SpreadFear(int phase) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "SpreadFear;Int32",
    (ReactionManagerComponent_SpreadFear x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_SpreadFear(
    ReactionManagerComponent self,
    int phase
);

void CreateFearArea(sense.StimuliEvent stimEvent, int fearPhase) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "CreateFearArea;StimuliEventInt32",
    (ReactionManagerComponent_CreateFearArea x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_CreateFearArea(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent,
    int fearPhase
);

bool ShouldFearInPlace(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ShouldFearInPlace;StimuliEvent",
    (ReactionManagerComponent_ShouldFearInPlace x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ShouldFearInPlace(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

void TriggerFacialLookAtReaction(bool? forceFear, bool? playVO) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "TriggerFacialLookAtReaction;BoolBool",
    (ReactionManagerComponent_TriggerFacialLookAtReaction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_TriggerFacialLookAtReaction(
    ReactionManagerComponent self,
    bool? forceFear,
    bool? playVO
);

void TriggerFearFacial(int phase) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "TriggerFearFacial;Int32",
    (ReactionManagerComponent_TriggerFearFacial x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_TriggerFearFacial(
    ReactionManagerComponent self,
    int phase
);

void ResetFacial(float cooldown) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "ResetFacial;Float",
    (ReactionManagerComponent_ResetFacial x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ResetFacial(
    ReactionManagerComponent self,
    float cooldown
);

bool OnResetLookatReactionEvent(ResetLookatReactionEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnResetLookatReactionEvent",
    (ReactionManagerComponent_OnResetLookatReactionEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnResetLookatReactionEvent(
    ReactionManagerComponent self,
    ResetLookatReactionEvent? evt
);

bool OnResetFacialEvent(ResetFacialEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnResetFacialEvent",
    (ReactionManagerComponent_OnResetFacialEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnResetFacialEvent(
    ReactionManagerComponent self,
    ResetFacialEvent? evt
);

bool CanTriggerExpressionLookAt() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "CanTriggerExpressionLookAt;",
    (ReactionManagerComponent_CanTriggerExpressionLookAt x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_CanTriggerExpressionLookAt(
    ReactionManagerComponent self
);

bool ShouldFearWhileAggressiveCrowdNPCCombat(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ShouldFearWhileAggressiveCrowdNPCCombat;StimuliEvent",
    (ReactionManagerComponent_ShouldFearWhileAggressiveCrowdNPCCombat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ShouldFearWhileAggressiveCrowdNPCCombat(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool ShouldTriggerAggressiveCrowdNPCCombat(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ShouldTriggerAggressiveCrowdNPCCombat;StimuliEvent",
    (ReactionManagerComponent_ShouldTriggerAggressiveCrowdNPCCombat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ShouldTriggerAggressiveCrowdNPCCombat(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool IsPlayerFearThreat() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsPlayerFearThreat;",
    (ReactionManagerComponent_IsPlayerFearThreat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsPlayerFearThreat(
    ReactionManagerComponent self
);

bool IsPlayerCarryingBody(WeakHandle<PlayerPuppet> playerPuppet) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsPlayerCarryingBody;PlayerPuppet",
    (ReactionManagerComponent_IsPlayerCarryingBody x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsPlayerCarryingBody(
    ReactionManagerComponent self,
    WeakHandle<PlayerPuppet> playerPuppet
);

void SetCrowdRunningAwayAnimFeature(game.data.StimType stimType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "SetCrowdRunningAwayAnimFeature;gamedataStimType",
    (ReactionManagerComponent_SetCrowdRunningAwayAnimFeature x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_SetCrowdRunningAwayAnimFeature(
    ReactionManagerComponent self,
    game.data.StimType stimType
);

bool SafeToExitFear() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "SafeToExitFear;",
    (ReactionManagerComponent_SafeToExitFear x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_SafeToExitFear(
    ReactionManagerComponent self
);

bool SafeToExitPanicFear() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "SafeToExitPanicFear;",
    (ReactionManagerComponent_SafeToExitPanicFear x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_SafeToExitPanicFear(
    ReactionManagerComponent self
);

bool SurrenderToLeave() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "SurrenderToLeave;",
    (ReactionManagerComponent_SurrenderToLeave x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_SurrenderToLeave(
    ReactionManagerComponent self
);

bool CanTriggerReprimandOrder() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "CanTriggerReprimandOrder;",
    (ReactionManagerComponent_CanTriggerReprimandOrder x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_CanTriggerReprimandOrder(
    ReactionManagerComponent self
);

bool CanAskToHolsterWeapon() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "CanAskToHolsterWeapon;",
    (ReactionManagerComponent_CanAskToHolsterWeapon x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_CanAskToHolsterWeapon(
    ReactionManagerComponent self
);

void NotifySecuritySystem(game.data.StimType stimType, game.Object stimObject) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "NotifySecuritySystem;gamedataStimTypeGameObject",
    (ReactionManagerComponent_NotifySecuritySystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_NotifySecuritySystem(
    ReactionManagerComponent self,
    game.data.StimType stimType,
    game.Object? stimObject
);

void SetWarningMessage(string lockey) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "SetWarningMessage;script_ref<String>",
    (ReactionManagerComponent_SetWarningMessage x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_SetWarningMessage(
    ReactionManagerComponent self,
    string lockey
);

bool OnTriggerDelayedReactionEvent(TriggerDelayedReactionEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnTriggerDelayedReactionEvent",
    (ReactionManagerComponent_OnTriggerDelayedReactionEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnTriggerDelayedReactionEvent(
    ReactionManagerComponent self,
    TriggerDelayedReactionEvent? evt
);

bool OnExitWorkspotSequenceEvent(ExitWorkspotSequenceEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnExitWorkspotSequenceEvent",
    (ReactionManagerComponent_OnExitWorkspotSequenceEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnExitWorkspotSequenceEvent(
    ReactionManagerComponent self,
    ExitWorkspotSequenceEvent? evt
);

bool OnDeescalateFearInVehicle(DeescalateFearInVehicle evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnDeescalateFearInVehicle",
    (ReactionManagerComponent_OnDeescalateFearInVehicle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnDeescalateFearInVehicle(
    ReactionManagerComponent self,
    DeescalateFearInVehicle? evt
);

bool OnCrowdSettingsEvent(CrowdSettingsEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnCrowdSettingsEvent",
    (ReactionManagerComponent_OnCrowdSettingsEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnCrowdSettingsEvent(
    ReactionManagerComponent self,
    CrowdSettingsEvent? evt
);

int GetFearReactionPhase(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetFearReactionPhase;StimuliEvent",
    (ReactionManagerComponent_GetFearReactionPhase x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetFearReactionPhase(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool ShouldInterruptCurrentFearStage(int fearPhase) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ShouldInterruptCurrentFearStage;Int32",
    (ReactionManagerComponent_ShouldInterruptCurrentFearStage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ShouldInterruptCurrentFearStage(
    ReactionManagerComponent self,
    int fearPhase
);

int ConvertFearStageToFearPhase(game.FearStage fearStage) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ConvertFearStageToFearPhase;gameFearStage",
    (ReactionManagerComponent_ConvertFearStageToFearPhase x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ConvertFearStageToFearPhase(
    ReactionManagerComponent self,
    game.FearStage fearStage
);

int GetSpreadFearPhase(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetSpreadFearPhase;StimuliEvent",
    (ReactionManagerComponent_GetSpreadFearPhase x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetSpreadFearPhase(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool CanReactInVehicle(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "CanReactInVehicle;StimuliEvent",
    (ReactionManagerComponent_CanReactInVehicle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_CanReactInVehicle(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool OnCrowdCallingPoliceEvent(CrowdCallingPoliceEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnCrowdCallingPoliceEvent",
    (ReactionManagerComponent_OnCrowdCallingPoliceEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnCrowdCallingPoliceEvent(
    ReactionManagerComponent self,
    CrowdCallingPoliceEvent? evt
);

void CheckStalk(game.Object target, float timeout) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "CheckStalk;GameObjectFloat",
    (ReactionManagerComponent_CheckStalk x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_CheckStalk(
    ReactionManagerComponent self,
    game.Object? target,
    float timeout
);

void CheckComfortZone() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "CheckComfortZone;",
    (ReactionManagerComponent_CheckComfortZone x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_CheckComfortZone(
    ReactionManagerComponent self
);

bool OnDisturbingComfortZoneEvent(DisturbingComfortZone evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnDisturbingComfortZoneEvent",
    (ReactionManagerComponent_OnDisturbingComfortZoneEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnDisturbingComfortZoneEvent(
    ReactionManagerComponent self,
    DisturbingComfortZone? evt
);

bool OnCheckComfortZoneEvent(CheckComfortZoneEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnCheckComfortZoneEvent",
    (ReactionManagerComponent_OnCheckComfortZoneEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnCheckComfortZoneEvent(
    ReactionManagerComponent self,
    CheckComfortZoneEvent? evt
);

float GetOutputPriority(game.data.Output output) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetOutputPriority;gamedataOutput",
    (ReactionManagerComponent_GetOutputPriority x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetOutputPriority(
    ReactionManagerComponent self,
    game.data.Output output
);

bool DelayReaction(game.data.StimType stimType) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "DelayReaction;gamedataStimType",
    (ReactionManagerComponent_DelayReaction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_DelayReaction(
    ReactionManagerComponent self,
    game.data.StimType stimType
);

void SelectFacialEmotion(out LookAtData lookAtData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "SelectFacialEmotion;LookAtData",
    (ReactionManagerComponent_SelectFacialEmotion x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_SelectFacialEmotion(
    ReactionManagerComponent self,
    LookAtData lookAtData
);

void MapLookAtVO(LookAtData lookAtData, out CName vo) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "MapLookAtVO;LookAtDataCName",
    (ReactionManagerComponent_MapLookAtVO x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_MapLookAtVO(
    ReactionManagerComponent self,
    LookAtData lookAtData,
    CName vo
);

bool ActivateReactionLookAt(ent.Entity targetEntity, bool? end, bool? repeat, float? duration, bool? upperBody, bool? inVehicle)

RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ActivateReactionLookAt;EntityBoolBoolFloatBoolBool",
    (ReactionManagerComponent_ActivateReactionLookAt x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ActivateReactionLookAt(
    ReactionManagerComponent self,
    ent.Entity? targetEntity,
    bool? end,
    bool? repeat,
    float? duration,
    bool? upperBody,
    bool? inVehicle
);

bool ActivateUndeadLookAt(ent.Entity targetEntity) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ActivateUndeadLookAt;Entity",
    (ReactionManagerComponent_ActivateUndeadLookAt x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ActivateUndeadLookAt(
    ReactionManagerComponent self,
    ent.Entity? targetEntity
);

bool DeactiveLookAt(bool? repeat) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "DeactiveLookAt;Bool",
    (ReactionManagerComponent_DeactiveLookAt x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_DeactiveLookAt(
    ReactionManagerComponent self,
    bool? repeat
);

void OnReactionStarted(AIReactionData reactionData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "OnReactionStarted;AIReactionData",
    (ReactionManagerComponent_OnReactionStarted x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnReactionStarted(
    ReactionManagerComponent self,
    AIReactionData? reactionData
);

float GetCurrentStimTimeStamp() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetCurrentStimTimeStamp;",
    (ReactionManagerComponent_GetCurrentStimTimeStamp x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetCurrentStimTimeStamp(
    ReactionManagerComponent self
);

int GetCurrentStimThresholdValue() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetCurrentStimThresholdValue;",
    (ReactionManagerComponent_GetCurrentStimThresholdValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetCurrentStimThresholdValue(
    ReactionManagerComponent self
);

float GetCurrentStealthStimTimeStamp() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetCurrentStealthStimTimeStamp;",
    (ReactionManagerComponent_GetCurrentStealthStimTimeStamp x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetCurrentStealthStimTimeStamp(
    ReactionManagerComponent self
);

int GetCurrentStealthStimThresholdValue() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetCurrentStealthStimThresholdValue;",
    (ReactionManagerComponent_GetCurrentStealthStimThresholdValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetCurrentStealthStimThresholdValue(
    ReactionManagerComponent self
);

void AddInvestigatedBody(ent.EntityID bodyID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "AddInvestigatedBody;EntityID",
    (ReactionManagerComponent_AddInvestigatedBody x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_AddInvestigatedBody(
    ReactionManagerComponent self,
    ent.EntityID bodyID
);

bool OnAddInvestigatedBodyEvent(AddInvestigatorEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnAddInvestigatedBodyEvent",
    (ReactionManagerComponent_OnAddInvestigatedBodyEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnAddInvestigatedBodyEvent(
    ReactionManagerComponent self,
    AddInvestigatorEvent? evt
);

void InformInvestigators() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "InformInvestigators;",
    (ReactionManagerComponent_InformInvestigators x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_InformInvestigators(
    ReactionManagerComponent self
);

bool OnBodyPickedUp(SetBodyPositionEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnBodyPickedUp",
    (ReactionManagerComponent_OnBodyPickedUp x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnBodyPickedUp(
    ReactionManagerComponent self,
    SetBodyPositionEvent? evt
);

void OnReactionEnded() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "OnReactionEnded;",
    (ReactionManagerComponent_OnReactionEnded x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnReactionEnded(
    ReactionManagerComponent self
);

bool OnResetReactionEvent(ResetReactionEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnResetReactionEvent",
    (ReactionManagerComponent_OnResetReactionEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnResetReactionEvent(
    ReactionManagerComponent self,
    ResetReactionEvent? evt
);

bool OnBodyInvestigated(BodyInvestigatedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnBodyInvestigated",
    (ReactionManagerComponent_OnBodyInvestigated x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnBodyInvestigated(
    ReactionManagerComponent self,
    BodyInvestigatedEvent? evt
);

bool InvestigatingAlready(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "InvestigatingAlready;StimuliEvent",
    (ReactionManagerComponent_InvestigatingAlready x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_InvestigatingAlready(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

ScriptedPuppet? GetOwnerPuppet() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetOwnerPuppet(
    ReactionManagerComponent self
);

bool HasCombatTarget() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "HasCombatTarget;",
    (ReactionManagerComponent_HasCombatTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_HasCombatTarget(
    ReactionManagerComponent self
);

void PickCloserTarget(sense.StimuliEvent newStimEvent, out bool updateByActive) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "PickCloserTarget;StimuliEventBool",
    (ReactionManagerComponent_PickCloserTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_PickCloserTarget(
    ReactionManagerComponent self,
    sense.StimuliEvent? newStimEvent,
    bool updateByActive
);

bool DidTargetMakeMeAlerted(game.Object target) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "DidTargetMakeMeAlerted;GameObject",
    (ReactionManagerComponent_DidTargetMakeMeAlerted x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool IsTargetInterestingForRecentSquadMates(game.Object target, game.Object ally) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsTargetInterestingForRecentSquadMates;GameObjectGameObject",
    (ReactionManagerComponent_IsTargetInterestingForRecentSquadMates x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsTargetInterestingForRecentSquadMates(
    ReactionManagerComponent self,
    game.Object? target,
    game.Object? ally
);

bool IsPlayerAiming() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsPlayerAiming;",
    (ReactionManagerComponent_IsPlayerAiming x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsPlayerAiming(
    ReactionManagerComponent self
);

AIReactionData? GetDesiredReactionData() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetDesiredReactionData;",
    (ReactionManagerComponent_GetDesiredReactionData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.AIReactionData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetDesiredReactionData(
    ReactionManagerComponent self
);

AIReactionData? GetActiveReactionData() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetActiveReactionData;",
    (ReactionManagerComponent_GetActiveReactionData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.AIReactionData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetActiveReactionData(
    ReactionManagerComponent self
);

AIReactionData? GetActiveOrDesiredReactionData() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetActiveOrDesiredReactionData;",
    (ReactionManagerComponent_GetActiveOrDesiredReactionData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.AIReactionData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetActiveOrDesiredReactionData(
    ReactionManagerComponent self
);

game.data.Output GetDesiredReactionName() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetDesiredReactionName;",
    (ReactionManagerComponent_GetDesiredReactionName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Output>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetDesiredReactionName(
    ReactionManagerComponent self
);

game.data.Output GetPendingReactionName() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetPendingReactionName;",
    (ReactionManagerComponent_GetPendingReactionName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Output>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetPendingReactionName(
    ReactionManagerComponent self
);

game.data.Output GetReactionBehaviorName() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetReactionBehaviorName;",
    (ReactionManagerComponent_GetReactionBehaviorName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Output>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetReactionBehaviorName(
    ReactionManagerComponent self
);

AIReactionData?[] GetReactionCache() RTTI
StimEventTaskData?[] GetStimuliCache() RTTI

game.data.StimType GetReceivedStimType() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetReceivedStimType;",
    (ReactionManagerComponent_GetReceivedStimType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.StimType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetReceivedStimType(
    ReactionManagerComponent self
);

game.data.StimPropagation GetReceivedStimPropagation() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetReceivedStimPropagation;",
    (ReactionManagerComponent_GetReceivedStimPropagation x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.StimPropagation>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetReceivedStimPropagation(
    ReactionManagerComponent self
);

bool GetWorkSpotReactionFlag() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetWorkSpotReactionFlag;",
    (ReactionManagerComponent_GetWorkSpotReactionFlag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetWorkSpotReactionFlag(
    ReactionManagerComponent self
);

bool IsTargetInterestingForPerception(game.Object target) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsTargetInterestingForPerception;GameObject",
    (ReactionManagerComponent_IsTargetInterestingForPerception x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

game.IBlackboard? GetPuppetReactionBlackboard() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetPuppetReactionBlackboard;",
    (ReactionManagerComponent_GetPuppetReactionBlackboard x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IBlackboard>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetPuppetReactionBlackboard(
    ReactionManagerComponent self
);

bool IsInitAnimShock(game.data.Output behavior) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsInitAnimShock;gamedataOutput",
    (ReactionManagerComponent_IsInitAnimShock x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsInitAnimShock(
    ReactionManagerComponent self,
    game.data.Output behavior
);

bool IsInitAnimCall(game.data.StimType stim) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsInitAnimCall;gamedataStimType",
    (ReactionManagerComponent_IsInitAnimCall x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsInitAnimCall(
    ReactionManagerComponent self,
    game.data.StimType stim
);

bool GetInPendingBehavior() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetInPendingBehavior;",
    (ReactionManagerComponent_GetInPendingBehavior x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetInPendingBehavior(
    ReactionManagerComponent self
);

WeakHandle<game.data.ReactionPreset_Record> GetReactionPreset() RTTI

bool IsInPendingBehavior() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsInPendingBehavior;",
    (ReactionManagerComponent_IsInPendingBehavior x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsInPendingBehavior(
    ReactionManagerComponent self
);

bool IsAlertedByDeadBody() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsAlertedByDeadBody;",
    (ReactionManagerComponent_IsAlertedByDeadBody x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsAlertedByDeadBody(
    ReactionManagerComponent self
);

int GetPreviousFearPhase() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetPreviousFearPhase;",
    (ReactionManagerComponent_GetPreviousFearPhase x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetPreviousFearPhase(
    ReactionManagerComponent self
);

sense.StimuliEvent?[] GetEnvironmentalHazards() RTTI

game.data.StimPriority GetActiveStimPriority() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetActiveStimPriority;",
    (ReactionManagerComponent_GetActiveStimPriority x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.StimPriority>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetActiveStimPriority(
    ReactionManagerComponent self
);

game.Object? GetActiveStimTarget() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetActiveStimTarget;",
    (ReactionManagerComponent_GetActiveStimTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetActiveStimTarget(
    ReactionManagerComponent self
);

Vector4 GetActiveStimSource() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetActiveStimSource;",
    (ReactionManagerComponent_GetActiveStimSource x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetActiveStimSource(
    ReactionManagerComponent self
);

bool ShouldUpdateThreatPosition(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ShouldUpdateThreatPosition;StimuliEvent",
    (ReactionManagerComponent_ShouldUpdateThreatPosition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ShouldUpdateThreatPosition(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool ShouldTriggerGrenadeDodgeBehavior(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ShouldTriggerGrenadeDodgeBehavior;StimuliEvent",
    (ReactionManagerComponent_ShouldTriggerGrenadeDodgeBehavior x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ShouldTriggerGrenadeDodgeBehavior(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool CanTriggerPanicInCombat(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "CanTriggerPanicInCombat;StimuliEvent",
    (ReactionManagerComponent_CanTriggerPanicInCombat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_CanTriggerPanicInCombat(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool CanStimInterruptCombat(sense.StimuliEvent stimEvent, bool canIgnorePlayerCombatStim) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "CanStimInterruptCombat;StimuliEventBool",
    (ReactionManagerComponent_CanStimInterruptCombat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_CanStimInterruptCombat(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent,
    bool canIgnorePlayerCombatStim
);

bool ShouldAddToIgnoreList(game.data.StimType stimType) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ShouldAddToIgnoreList;gamedataStimType",
    (ReactionManagerComponent_ShouldAddToIgnoreList x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ShouldAddToIgnoreList(
    ReactionManagerComponent self,
    game.data.StimType stimType
);

bool IsTargetVisible(game.Object target) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsTargetVisible;GameObject",
    (ReactionManagerComponent_IsTargetVisible x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool IsTargetDetected(game.Object target) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsTargetDetected;GameObject",
    (ReactionManagerComponent_IsTargetDetected x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool SourceAttitude(WeakHandle<game.Object> source, EAIAttitude attitude) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "SourceAttitude;GameObjectEAIAttitude",
    (ReactionManagerComponent_SourceAttitude x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_SourceAttitude(
    ReactionManagerComponent self,
    WeakHandle<game.Object> source,
    EAIAttitude attitude
);

bool IsTargetInFront(WeakHandle<game.Object> target, float? frontAngle, bool? meInFrontOfTarget, bool? checkFullAngle) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsTargetInFront;GameObjectFloatBoolBool",
    (ReactionManagerComponent_IsTargetInFront x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsTargetInFront(
    ReactionManagerComponent self,
    WeakHandle<game.Object> target,
    float? frontAngle,
    bool? meInFrontOfTarget,
    bool? checkFullAngle
);

bool IsTargetBehind(WeakHandle<game.Object> target, float? angle, bool? meBehindOfTarget) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsTargetBehind;GameObjectFloatBool",
    (ReactionManagerComponent_IsTargetBehind x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsTargetBehind(
    ReactionManagerComponent self,
    WeakHandle<game.Object> target,
    float? angle,
    bool? meBehindOfTarget
);

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

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsTargetInMovementDirection;GameObject",
    (ReactionManagerComponent_IsTargetInMovementDirection x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool IsTargetPositionClose(Vector4 targetPos, float distance) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsTargetPositionClose;Vector4Float",
    (ReactionManagerComponent_IsTargetPositionClose x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsTargetPositionClose(
    ReactionManagerComponent self,
    Vector4 targetPos,
    float distance
);

bool IsTargetClose(WeakHandle<game.Object> target, float distance) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsTargetClose;GameObjectFloat",
    (ReactionManagerComponent_IsTargetClose x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsTargetClose(
    ReactionManagerComponent self,
    WeakHandle<game.Object> target,
    float distance
);

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

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsTargetVeryClose;GameObject",
    (ReactionManagerComponent_IsTargetVeryClose x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool TargetVerticalCheck(WeakHandle<game.Object> target, float? distance) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "TargetVerticalCheck;GameObjectFloat",
    (ReactionManagerComponent_TargetVerticalCheck x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_TargetVerticalCheck(
    ReactionManagerComponent self,
    WeakHandle<game.Object> target,
    float? distance
);

bool CheckHearingDistance(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "CheckHearingDistance;StimuliEvent",
    (ReactionManagerComponent_CheckHearingDistance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_CheckHearingDistance(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool IsVisibleRaycast(sense.StimuliEvent stimEvent, Vector4 stimOffset) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsVisibleRaycast;StimuliEventVector4",
    (ReactionManagerComponent_IsVisibleRaycast x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsVisibleRaycast(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent,
    Vector4 stimOffset
);

bool IsTargetVisibleBeyondSenses(sense.StimuliEvent stimEvent, AIReactionData reactionData) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsTargetVisibleBeyondSenses;StimuliEventAIReactionData",
    (ReactionManagerComponent_IsTargetVisibleBeyondSenses x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsTargetVisibleBeyondSenses(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent,
    AIReactionData? reactionData
);

bool IsPlayerInZone(game.PSMZones zone) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsPlayerInZone;gamePSMZones",
    (ReactionManagerComponent_IsPlayerInZone x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsPlayerInZone(
    ReactionManagerComponent self,
    game.PSMZones zone
);

bool IsSameStimulus(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsSameStimulus;StimuliEvent",
    (ReactionManagerComponent_IsSameStimulus x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsSameStimulus(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool IsSameSourceObject(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsSameSourceObject;StimuliEvent",
    (ReactionManagerComponent_IsSameSourceObject x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsSameSourceObject(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool IsInList(StimEventData[] list, StimEventData stimData) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsInList;script_ref<array<StimEventData>>StimEventData",
    (ReactionManagerComponent_IsInList x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsInList(
    ReactionManagerComponent self,
    StimEventData[] list,
    StimEventData stimData
);

bool IsLowerPriority(sense.StimuliEvent stimEvent, game.data.StimPriority activePriority) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsLowerPriority;StimuliEventgamedataStimPriority",
    (ReactionManagerComponent_IsLowerPriority x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsLowerPriority(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent,
    game.data.StimPriority activePriority
);

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

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsTargetSquadAlly;GameObject",
    (ReactionManagerComponent_IsTargetSquadAlly x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

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

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsTargetInSameSecuritySystem;GameObject",
    (ReactionManagerComponent_IsTargetInSameSecuritySystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool IsTargetMelee(game.Object target) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsTargetMelee;GameObject",
    (ReactionManagerComponent_IsTargetMelee x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool IsTargetArmed(game.Object target) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsTargetArmed;GameObject",
    (ReactionManagerComponent_IsTargetArmed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

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

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsTargetRecentSquadAlly;GameObject",
    (ReactionManagerComponent_IsTargetRecentSquadAlly x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool ShouldHelpTargetFromSameAttitudeGroup(WeakHandle<game.Object> target, WeakHandle<game.Object> targetOfTarget) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ShouldHelpTargetFromSameAttitudeGroup;GameObjectGameObject",
    (ReactionManagerComponent_ShouldHelpTargetFromSameAttitudeGroup x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool ShouldReactToNPCGrenade(WeakHandle<BaseGrenade> grenade) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ShouldReactToNPCGrenade;BaseGrenade",
    (ReactionManagerComponent_ShouldReactToNPCGrenade x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ShouldReactToNPCGrenade(
    ReactionManagerComponent self,
    WeakHandle<BaseGrenade> grenade
);

bool ShouldPreventionReact(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ShouldPreventionReact;StimuliEvent",
    (ReactionManagerComponent_ShouldPreventionReact x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ShouldPreventionReact(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

bool IsIllegalActionAgainstGanger(sense.StimuliEvent stimEvent) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsIllegalActionAgainstGanger;StimuliEvent",
    (ReactionManagerComponent_IsIllegalActionAgainstGanger x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsIllegalActionAgainstGanger(
    ReactionManagerComponent self,
    sense.StimuliEvent? stimEvent
);

void SetBaseReactionPreset(bool? ignoreSavedPreset) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "SetBaseReactionPreset;Bool",
    (ReactionManagerComponent_SetBaseReactionPreset x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_SetBaseReactionPreset(
    ReactionManagerComponent self,
    bool? ignoreSavedPreset
);

void SetReactionPreset(game.data.ReactionPreset_Record reactionPreset) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "SetReactionPreset;ReactionPreset_Record",
    (ReactionManagerComponent_SetReactionPreset x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_SetReactionPreset(
    ReactionManagerComponent self,
    game.data.ReactionPreset_Record? reactionPreset
);

void MapReactionPreset(string mappingName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "MapReactionPreset;script_ref<String>",
    (ReactionManagerComponent_MapReactionPreset x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_MapReactionPreset(
    ReactionManagerComponent self,
    string mappingName
);

void ReevaluateReactionPreset(bool? ignoreSavedPreset) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "ReevaluateReactionPreset;Bool",
    (ReactionManagerComponent_ReevaluateReactionPreset x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ReevaluateReactionPreset(
    ReactionManagerComponent self,
    bool? ignoreSavedPreset
);

void CheckCrowd() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "CheckCrowd;",
    (ReactionManagerComponent_CheckCrowd x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_CheckCrowd(
    ReactionManagerComponent self
);

void SetDownedBodyVisibleComponent(bool visible, CName description) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "SetDownedBodyVisibleComponent;BoolCName",
    (ReactionManagerComponent_SetDownedBodyVisibleComponent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_SetDownedBodyVisibleComponent(
    ReactionManagerComponent self,
    bool visible,
    CName description
);

void OnIncapacitated(game.Object instigator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "OnIncapacitated;GameObject",
    (ReactionManagerComponent_OnIncapacitated x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnIncapacitated(
    ReactionManagerComponent self,
    game.Object? instigator
);

void SendIgnoreEventToSquad(IgnoreListEvent? ignoreListEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "SendIgnoreEventToSquad;IgnoreListEvent",
    (ReactionManagerComponent_SendIgnoreEventToSquad x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_SendIgnoreEventToSquad(
    ReactionManagerComponent self,
    IgnoreListEvent? ignoreListEvent
);

float GetThreatDistanceSquared(game.Object threat) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetThreatDistanceSquared;GameObject",
    (ReactionManagerComponent_GetThreatDistanceSquared x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetThreatDistanceSquared(
    ReactionManagerComponent self,
    game.Object? threat
);

CName GetFearAnimWrapper(int fearPhase) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetFearAnimWrapper;Int32",
    (ReactionManagerComponent_GetFearAnimWrapper x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetFearAnimWrapper(
    ReactionManagerComponent self,
    int fearPhase
);

CName GetRandomFearLocomotionAnimWrapper(int fearPhase, game.data.StimType? stimType) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "GetRandomFearLocomotionAnimWrapper;Int32gamedataStimType",
    (ReactionManagerComponent_GetRandomFearLocomotionAnimWrapper x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_GetRandomFearLocomotionAnimWrapper(
    ReactionManagerComponent self,
    int fearPhase,
    game.data.StimType? stimType
);

void ResetAllFearAnimWrappers() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "ResetAllFearAnimWrappers;",
    (ReactionManagerComponent_ResetAllFearAnimWrappers x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ResetAllFearAnimWrappers(
    ReactionManagerComponent self
);

bool IsFearLocomotionWrapperSet() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsFearLocomotionWrapperSet;",
    (ReactionManagerComponent_IsFearLocomotionWrapperSet x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsFearLocomotionWrapperSet(
    ReactionManagerComponent self
);

void ReevaluateReaction() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "ReevaluateReaction;",
    (ReactionManagerComponent_ReevaluateReaction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_ReevaluateReaction(
    ReactionManagerComponent self
);

bool CombatGracePeriodPassed(PlayerPuppet player) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "CombatGracePeriodPassed;PlayerPuppet",
    (ReactionManagerComponent_CombatGracePeriodPassed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_CombatGracePeriodPassed(
    ReactionManagerComponent self,
    PlayerPuppet? player
);

bool OnStanceLevelChanged(game.events.StanceStateChangeEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnStanceLevelChanged",
    (ReactionManagerComponent_OnStanceLevelChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnStanceLevelChanged(
    ReactionManagerComponent self,
    game.events.StanceStateChangeEvent? evt
);

bool OnHighLevelStateDataEvent(game.events.HighLevelStateDataEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnHighLevelStateDataEvent",
    (ReactionManagerComponent_OnHighLevelStateDataEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnHighLevelStateDataEvent(
    ReactionManagerComponent self,
    game.events.HighLevelStateDataEvent? evt
);

bool OnRagdollEnabledEvent(ent.RagdollNotifyEnabledEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnRagdollEnabledEvent",
    (ReactionManagerComponent_OnRagdollEnabledEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnRagdollEnabledEvent(
    ReactionManagerComponent self,
    ent.RagdollNotifyEnabledEvent? evt
);

void OnGameDetach() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "OnGameDetach;",
    (ReactionManagerComponent_OnGameDetach x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnGameDetach(
    ReactionManagerComponent self
);

bool OnIncapacitatedEvent(IncapacitatedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnIncapacitatedEvent",
    (ReactionManagerComponent_OnIncapacitatedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnIncapacitatedEvent(
    ReactionManagerComponent self,
    IncapacitatedEvent? evt
);

bool OnIgnoreListEvent(IgnoreListEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnIgnoreListEvent",
    (ReactionManagerComponent_OnIgnoreListEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnIgnoreListEvent(
    ReactionManagerComponent self,
    IgnoreListEvent? evt
);

bool OnNPCRoleChangeEvent(NPCRoleChangeEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnNPCRoleChangeEvent",
    (ReactionManagerComponent_OnNPCRoleChangeEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnNPCRoleChangeEvent(
    ReactionManagerComponent self,
    NPCRoleChangeEvent? evt
);

bool OnWorkspotStartedEvent(work.WorkspotStartedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnWorkspotStartedEvent",
    (ReactionManagerComponent_OnWorkspotStartedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnWorkspotStartedEvent(
    ReactionManagerComponent self,
    work.WorkspotStartedEvent? evt
);

bool OnWorkspotFinishedEvent(work.WorkspotFinishedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnWorkspotFinishedEvent",
    (ReactionManagerComponent_OnWorkspotFinishedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnWorkspotFinishedEvent(
    ReactionManagerComponent self,
    work.WorkspotFinishedEvent? evt
);

bool OnStatusEffectApplied(game.events.ApplyStatusEffectEvent evt) RTTI

Generated hook

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

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

bool OnStatusEffectRemoved(game.events.RemoveStatusEffect evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnStatusEffectRemoved",
    (ReactionManagerComponent_OnStatusEffectRemoved x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnStatusEffectRemoved(
    ReactionManagerComponent self,
    game.events.RemoveStatusEffect? evt
);

bool OnReactionFinishedEvent(work.ReactionFinishedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnReactionFinishedEvent",
    (ReactionManagerComponent_OnReactionFinishedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnReactionFinishedEvent(
    ReactionManagerComponent self,
    work.ReactionFinishedEvent? evt
);

bool OnReevaluatePresetEvent(ReevaluatePresetEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnReevaluatePresetEvent",
    (ReactionManagerComponent_OnReevaluatePresetEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnReevaluatePresetEvent(
    ReactionManagerComponent self,
    ReevaluatePresetEvent? evt
);

bool OnReactionChangeRequestEvent(game.events.ReactionChangeRequestEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnReactionChangeRequestEvent",
    (ReactionManagerComponent_OnReactionChangeRequestEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnReactionChangeRequestEvent(
    ReactionManagerComponent self,
    game.events.ReactionChangeRequestEvent? evt
);

bool OnPendingBehaviorChanged(bool value) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnPendingBehaviorChanged",
    (ReactionManagerComponent_OnPendingBehaviorChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool OnAttitudeGroupChanged(game.events.AttitudeGroupChangedEvent evt) RTTI

Generated hook

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

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

float CalculateMoveTypeChangeDelay(float totalDistance, float distanceLeft, float minDistance, float maxDelay) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "CalculateMoveTypeChangeDelay;FloatFloatFloatFloat",
    (ReactionManagerComponent_CalculateMoveTypeChangeDelay x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_CalculateMoveTypeChangeDelay(
    ReactionManagerComponent self,
    float totalDistance,
    float distanceLeft,
    float minDistance,
    float maxDelay
);

bool OnCrosswalkEvent(game.interactions.CrosswalkEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnCrosswalkEvent",
    (ReactionManagerComponent_OnCrosswalkEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnCrosswalkEvent(
    ReactionManagerComponent self,
    game.interactions.CrosswalkEvent? evt
);

bool OnBumpEvent(game.interactions.BumpEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnBumpEvent",
    (ReactionManagerComponent_OnBumpEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnBumpEvent(
    ReactionManagerComponent self,
    game.interactions.BumpEvent? evt
);

bool OnClearFearOnHitEvent(ClearFearOnHitEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnClearFearOnHitEvent",
    (ReactionManagerComponent_OnClearFearOnHitEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnClearFearOnHitEvent(
    ReactionManagerComponent self,
    ClearFearOnHitEvent? evt
);

void PlayBumpInWorkspot(game.interactions.BumpSide side, Vector4 direction) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "PlayBumpInWorkspot;gameinteractionsBumpSideVector4",
    (ReactionManagerComponent_PlayBumpInWorkspot x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_PlayBumpInWorkspot(
    ReactionManagerComponent self,
    game.interactions.BumpSide side,
    Vector4 direction
);

bool OnVehicleHit(game.events.VehicleHitEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnVehicleHit",
    (ReactionManagerComponent_OnVehicleHit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnVehicleHit(
    ReactionManagerComponent self,
    game.events.VehicleHitEvent? evt
);

bool OnPlayerProximityStartEvent(world.PlayerProximityStartEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnPlayerProximityStartEvent",
    (ReactionManagerComponent_OnPlayerProximityStartEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnPlayerProximityStartEvent(
    ReactionManagerComponent self,
    world.PlayerProximityStartEvent? evt
);

bool OnPlayerProximityStopEvent(world.PlayerProximityStopEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnPlayerProximityStopEvent",
    (ReactionManagerComponent_OnPlayerProximityStopEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnPlayerProximityStopEvent(
    ReactionManagerComponent self,
    world.PlayerProximityStopEvent? evt
);

bool OnProximityLookatEvent(ProximityLookatEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnProximityLookatEvent",
    (ReactionManagerComponent_OnProximityLookatEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnProximityLookatEvent(
    ReactionManagerComponent self,
    ProximityLookatEvent? evt
);

bool OnSwapped(AIPuppetSwappedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnSwapped",
    (ReactionManagerComponent_OnSwapped x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnSwapped(
    ReactionManagerComponent self,
    AIPuppetSwappedEvent? evt
);

bool OnTeleported(AIPuppetTeleportedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnTeleported",
    (ReactionManagerComponent_OnTeleported x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnTeleported(
    ReactionManagerComponent self,
    AIPuppetTeleportedEvent? evt
);

bool OnInCrowd(game.InCrowd evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnInCrowd",
    (ReactionManagerComponent_OnInCrowd x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnInCrowd(
    ReactionManagerComponent self,
    game.InCrowd? evt
);

bool OnOutOfCrowd(game.OutOfCrowd evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnOutOfCrowd",
    (ReactionManagerComponent_OnOutOfCrowd x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnOutOfCrowd(
    ReactionManagerComponent self,
    game.OutOfCrowd? evt
);

bool IsInTrafficLane() RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "IsInTrafficLane;",
    (ReactionManagerComponent_IsInTrafficLane x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsInTrafficLane(
    ReactionManagerComponent self
);

bool OnVehicleHijackEvent(VehicleHijackEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnVehicleHijackEvent",
    (ReactionManagerComponent_OnVehicleHijackEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnVehicleHijackEvent(
    ReactionManagerComponent self,
    VehicleHijackEvent? evt
);

bool OnResetVehicleHijackEvent(ResetVehicleHijackEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnResetVehicleHijackEvent",
    (ReactionManagerComponent_OnResetVehicleHijackEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnResetVehicleHijackEvent(
    ReactionManagerComponent self,
    ResetVehicleHijackEvent? evt
);

bool OnSwapPreset(SwapPresetEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnSwapPreset",
    (ReactionManagerComponent_OnSwapPreset x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnSwapPreset(
    ReactionManagerComponent self,
    SwapPresetEvent? evt
);

bool OnRainEvent(world.RainEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnRainEvent",
    (ReactionManagerComponent_OnRainEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnRainEvent(
    ReactionManagerComponent self,
    world.RainEvent? evt
);

bool OnDistrurbComfortZoneAggressiveEvent(DistrurbComfortZoneAggressiveEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnDistrurbComfortZoneAggressiveEvent",
    (ReactionManagerComponent_OnDistrurbComfortZoneAggressiveEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnDistrurbComfortZoneAggressiveEvent(
    ReactionManagerComponent self,
    DistrurbComfortZoneAggressiveEvent? evt
);

bool OnAreaEnter(ent.AreaEnteredEvent trigger) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnAreaEnter",
    (ReactionManagerComponent_OnAreaEnter x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnAreaEnter(
    ReactionManagerComponent self,
    ent.AreaEnteredEvent? trigger
);

bool OnAreaExit(ent.AreaExitedEvent trigger) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnAreaExit",
    (ReactionManagerComponent_OnAreaExit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnAreaExit(
    ReactionManagerComponent self,
    ent.AreaExitedEvent? trigger
);

bool OnExplorationEnteredEvent(move.ExplorationEnteredEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnExplorationEnteredEvent",
    (ReactionManagerComponent_OnExplorationEnteredEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnExplorationEnteredEvent(
    ReactionManagerComponent self,
    move.ExplorationEnteredEvent? evt
);

bool OnExplorationLeftEvent(move.ExplorationLeftEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "OnExplorationLeftEvent",
    (ReactionManagerComponent_OnExplorationLeftEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_OnExplorationLeftEvent(
    ReactionManagerComponent self,
    move.ExplorationLeftEvent? evt
);

static bool ReactOnPlayerStealthStim(WeakHandle<game.Object> owner, WeakHandle<game.Object> target) staticRTTI global

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ReactionManagerComponent::ReactOnPlayerStealthStim;GameObjectGameObject",
    (ReactionManagerComponent_ReactOnPlayerStealthStim x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static void BodyInvestigated(WeakHandle<ScriptedPuppet> owner) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "ReactionManagerComponent::BodyInvestigated;ScriptedPuppet",
    (ReactionManagerComponent_BodyInvestigated x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_BodyInvestigated(
    WeakHandle<ScriptedPuppet> owner
);

static void SendVOEventToSquad(WeakHandle<game.Object> owner, CName voEvent, bool setOwnerAsAnsweringEntity, bool onlyForMembersInCombat)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "ReactionManagerComponent",
    "ReactionManagerComponent::SendVOEventToSquad;GameObjectCNameBoolBool",
    (ReactionManagerComponent_SendVOEventToSquad x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_SendVOEventToSquad(
    WeakHandle<game.Object> owner,
    CName voEvent,
    bool setOwnerAsAnsweringEntity,
    bool onlyForMembersInCombat
);

static bool IsTargetInFrontOfSource(WeakHandle<game.Object> source, WeakHandle<game.Object> target, float frontAngle, bool checkFullAngle)

staticRTTI global

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ReactionManagerComponent::IsTargetInFrontOfSource;GameObjectGameObjectFloatBool",
    (ReactionManagerComponent_IsTargetInFrontOfSource x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ReactionManagerComponent_IsTargetInFrontOfSource(
    WeakHandle<game.Object> source,
    WeakHandle<game.Object> target,
    float frontAngle,
    bool checkFullAngle
);

static bool InGunshotCone(WeakHandle<game.Object> shooter, WeakHandle<game.Object> target) staticRTTI global

Generated hook

re.Hooks.Place(
    "ReactionManagerComponent",
    "ReactionManagerComponent::InGunshotCone;GameObjectGameObject",
    (ReactionManagerComponent_InGunshotCone x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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