class

NPCPuppet

76 properties
277 functions

Extends ScriptedPuppet game.Puppet game.PuppetBase game.TimeDilatable game.Object ent.GameEntity ent.Entity IScriptable ISerializable

Properties

Property	Type	Offset
`lastHitEvent`	`game.events.HitEvent?`	`0x420`	scripted
`totalFrameReactionDamageReceived`	`float`	`0x430`	scripted
`totalFrameWoundsDamageReceived`	`float`	`0x434`	scripted
`totalFrameDismembermentDamageReceived`	`float`	`0x438`	scripted
`hitEventLock`	`ScriptReentrantRWLock`	`0x440`	scripted
`NPCManager`	`NPCManager?`	`0x450`	scripted
`customDeathDirection`	`int`	`0x460`	scripted
`deathOverrideState`	`bool`	`0x464`	scripted
`agonyState`	`bool`	`0x465`	scripted
`defensiveState`	`bool`	`0x466`	scripted
`lastSetupWorkspotActionEvent`	`game.SetupWorkspotActionEvent?`	`0x468`	scripted
`wasJustKilledOrDefeated`	`bool`	`0x478`	scripted
`shouldDie`	`bool`	`0x479`	scripted
`shouldBeDefeated`	`bool`	`0x47A`	scripted
`sentDownedEvent`	`bool`	`0x47B`	scripted
`isRagdolling`	`bool`	`0x47C`	scripted
`hasAnimatedRagdoll`	`bool`	`0x47D`	scripted
`disableCollisionRequested`	`bool`	`0x47E`	scripted
`ragdollInstigator`	`WeakHandle<game.Object>`	`0x480`	scripted
`ragdollSplattersSpawned`	`int`	`0x490`	scripted
`ragdollFloorSplashSpawned`	`bool`	`0x494`	scripted
`ragdollDamageData`	`RagdollDamagePollData`	`0x4A0`	scripted
`ragdollInitialPosition`	`Vector4`	`0x4D0`	scripted
`ragdollActivationTimestamp`	`float`	`0x4E0`	scripted
`ragdollImpactedNPCs`	`WeakHandle<NPCPuppet>[]`	`0x4E8`	scripted
`disableRagdollAfterRecovery`	`bool`	`0x4F8`	scripted
`thrownNPCNearbyCrowdNPCs`	`WeakHandle<ent.Entity>[]`	`0x500`	scripted
`isNotVisible`	`bool`	`0x510`	scripted
`deathListener`	`NPCDeathListener?`	`0x518`	scripted
`poiseListener`	`NPCPoiseListener?`	`0x528`	scripted
`godModeStatListener`	`NPCGodModeListener?`	`0x538`	scripted
`VehicleHitImmunityCallbackID`	`uint`	`0x548`	scripted
`npcCollisionComponent`	`ent.SimpleColliderComponent?`	`0x550`	scripted
`npcRagdollComponent`	`ent.IComponent?`	`0x560`	scripted
`npcTraceObstacleComponent`	`ent.SimpleColliderComponent?`	`0x570`	scripted
`npcMountedToPlayerComponents`	`ent.IComponent?[]`	`0x580`	scripted
`scavengeComponent`	`ScavengeComponent?`	`0x590`	scripted
`influenceComponent`	`game.influence.Component?`	`0x5A0`	scripted
`comfortZoneComponent`	`ent.IComponent?`	`0x5B0`	scripted
`isTargetingPlayer`	`bool`	`0x5C0`	scripted
`shouldBeImmuneToVehicleHit`	`bool`	`0x5C1`	scripted
`playerStatsListener`	`game.ScriptStatsListener?`	`0x5C8`	scripted
`upperBodyStateCallbackID`	`red.CallbackObject?`	`0x5D8`	scripted
`leftCyberwareStateCallbackID`	`red.CallbackObject?`	`0x5E8`	scripted
`meleeStateCallbackID`	`red.CallbackObject?`	`0x5F8`	scripted
`combatGadgetStateCallbackID`	`red.CallbackObject?`	`0x608`	scripted
`wasAimedAtLast`	`bool`	`0x618`	scripted
`wasCWChargedAtLast`	`bool`	`0x619`	scripted
`wasMeleeChargedAtLast`	`bool`	`0x61A`	scripted
`wasChargingGadgetAtLast`	`bool`	`0x61B`	scripted
`isLookedAt`	`bool`	`0x61C`	scripted
`cachedPlayerID`	`ent.EntityID`	`0x620`	scripted
`wasAggressiveCrowd`	`bool`	`0x628`	scripted
`canGoThroughDoors`	`bool`	`0x629`	scripted
`lastStatusEffectSignalSent`	`WeakHandle<game.data.StatusEffect_Record>`	`0x630`	scripted
`cachedStatusEffectAnim`	`WeakHandle<game.data.StatusEffect_Record>`	`0x640`	scripted
`resendStatusEffectSignalDelayID`	`game.DelayID`	`0x650`	scripted
`lastSEAppliedByPlayer`	`game.StatusEffect?`	`0x658`	scripted
`pendingSEEvent`	`game.events.ApplyStatusEffectEvent?`	`0x668`	scripted
`pendingDueToCachedSEAnim`	`bool`	`0x678`	scripted
`bounty`	`Bounty`	`0x680`	scripted
`cachedVFXList`	`WeakHandle<game.data.StatusEffectFX_Record>[]`	`0x6B8`	scripted
`cachedSFXList`	`WeakHandle<game.data.StatusEffectFX_Record>[]`	`0x6C8`	scripted
`isThrowingGrenadeToPlayer`	`bool`	`0x6D8`	scripted
`throwingGrenadeDelayEventID`	`game.DelayID`	`0x6DC`	scripted
`myKiller`	`WeakHandle<game.Object>`	`0x6E8`	scripted
`primaryThreatCalculationType`	`EAIThreatCalculationType`	`0x6F8`	scripted
`temporaryThreatCalculationType`	`EAIThreatCalculationType`	`0x6FC`	scripted
`isPlayerCompanionCached`	`bool`	`0x700`	scripted
`isPlayerCompanionCachedTimeStamp`	`float`	`0x704`	scripted
`quickHackEffectsApplied`	`uint`	`0x708`	scripted
`hackingResistanceMod`	`game.ConstantStatModifierData_Deprecated?`	`0x710`	scripted
`delayNonStealthQuickHackVictimEventID`	`game.DelayID`	`0x720`	scripted
`cachedIsPaperdoll`	`int`	`0x728`	scripted
`smartDespawnDelayID`	`game.DelayID`	`0x72C`	scripted
`despawnTicks`	`uint`	`0x734`	scripted

Functions

bool IsNPC() overrideRTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsNPC;",
    (NPCPuppet_IsNPC x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsNPC(
    NPCPuppet self
);

bool IsReplicable() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsReplicable;",
    (NPCPuppet_IsReplicable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsReplicable(
    NPCPuppet self
);

CName GetReplicatedStateClass() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetReplicatedStateClass;",
    (NPCPuppet_GetReplicatedStateClass x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetReplicatedStateClass(
    NPCPuppet self
);

void PrepareVendor() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "PrepareVendor;",
    (NPCPuppet_PrepareVendor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_PrepareVendor(
    NPCPuppet self
);

void PrepareVendorTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "PrepareVendorTask;ScriptTaskData",
    (NPCPuppet_PrepareVendorTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void RemoveVendor() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "RemoveVendor;",
    (NPCPuppet_RemoveVendor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_RemoveVendor(
    NPCPuppet self
);

void RemoveVendorTask() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "RemoveVendorTask;",
    (NPCPuppet_RemoveVendorTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_RemoveVendorTask(
    NPCPuppet self
);

void InitializeNPCManager() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "InitializeNPCManager;",
    (NPCPuppet_InitializeNPCManager x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_InitializeNPCManager(
    NPCPuppet self
);

bool IsPaperdoll() overrideRTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsPaperdoll;",
    (NPCPuppet_IsPaperdoll x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsPaperdoll(
    NPCPuppet self
);

bool IsPuppetInCombat() overrideRTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsPuppetInCombat;",
    (NPCPuppet_IsPuppetInCombat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsPuppetInCombat(
    NPCPuppet self
);

void ResetCompanionRoleCacheTimeStamp() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "ResetCompanionRoleCacheTimeStamp;",
    (NPCPuppet_ResetCompanionRoleCacheTimeStamp x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ResetCompanionRoleCacheTimeStamp(
    NPCPuppet self
);

bool OnPlayerCompanionCacheData(PlayerCompanionCacheDataEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnPlayerCompanionCacheData",
    (NPCPuppet_OnPlayerCompanionCacheData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnPlayerCompanionCacheData(
    NPCPuppet self,
    PlayerCompanionCacheDataEvent? evt
);

ent.EntityID GetPlayerID() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetPlayerID;",
    (NPCPuppet_GetPlayerID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.EntityID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetPlayerID(
    NPCPuppet self
);

bool IsPlayerCompanion() overrideRTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsPlayerCompanion;",
    (NPCPuppet_IsPlayerCompanion x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsPlayerCompanion(
    NPCPuppet self
);

bool OnRequestComponents(ent.EntityRequestComponentsInterface ri) overrideRTTI

Generated hook

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

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

bool OnTakeControl(ent.EntityResolveComponentsInterface ri) overrideRTTI

Generated hook

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

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

bool OnPostInitialize(ent.PostInitializeEvent evt) overrideRTTI

Generated hook

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

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

bool OnPreUninitialize(ent.PreUninitializeEvent evt) overrideRTTI

Generated hook

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

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

bool OnGameAttached() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnGameAttached(
    NPCPuppet self
);

bool OnDetach() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnDetach(
    NPCPuppet self
);

bool OnPreloadAnimationsEvent(PreloadAnimationsEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnPreloadAnimationsEvent",
    (NPCPuppet_OnPreloadAnimationsEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnPreloadAnimationsEvent(
    NPCPuppet self,
    PreloadAnimationsEvent? evt
);

bool OnDeviceLinkRequest(DeviceLinkRequest evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnDeviceLinkRequest",
    (NPCPuppet_OnDeviceLinkRequest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnDeviceLinkRequest(
    NPCPuppet self,
    DeviceLinkRequest? evt
);

void CreateListeners() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "CreateListeners;",
    (NPCPuppet_CreateListeners x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_CreateListeners(
    NPCPuppet self
);

void RemoveListeners() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "RemoveListeners;",
    (NPCPuppet_RemoveListeners x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_RemoveListeners(
    NPCPuppet self
);

bool OnDeviceLinkEstablished(DeviceLinkEstablished evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnDeviceLinkEstablished",
    (NPCPuppet_OnDeviceLinkEstablished x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnDeviceLinkEstablished(
    NPCPuppet self,
    DeviceLinkEstablished? evt
);

ScriptedPuppetPS? GetPS() overrideRTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetPS",
    (NPCPuppet_GetPS x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ScriptedPuppetPS>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetPS(
    NPCPuppet self
);

bool OnFactChangedEvent(game.FactChangedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnFactChangedEvent",
    (NPCPuppet_OnFactChangedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnFactChangedEvent(
    NPCPuppet self,
    game.FactChangedEvent? evt
);

void UpdateVehicleHitImmunity() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "UpdateVehicleHitImmunity;",
    (NPCPuppet_UpdateVehicleHitImmunity x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_UpdateVehicleHitImmunity(
    NPCPuppet self
);

Bounty GetBounty() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetBounty;",
    (NPCPuppet_GetBounty x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bounty>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetBounty(
    NPCPuppet self
);

void SetBountyAwarded(bool awarded) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SetBountyAwarded;Bool",
    (NPCPuppet_SetBountyAwarded x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SetBountyAwarded(
    NPCPuppet self,
    bool awarded
);

bool OnSetBountyAwardedEvent(SetBountyAwardedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnSetBountyAwardedEvent",
    (NPCPuppet_OnSetBountyAwardedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnSetBountyAwardedEvent(
    NPCPuppet self,
    SetBountyAwardedEvent? evt
);

bool OnSetBountyObjectEvent(SetBountyObjectEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnSetBountyObjectEvent",
    (NPCPuppet_OnSetBountyObjectEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnSetBountyObjectEvent(
    NPCPuppet self,
    SetBountyObjectEvent? evt
);

void SetBounty(Bounty bounty) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SetBounty;script_ref<Bounty>",
    (NPCPuppet_SetBounty x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SetBounty(
    NPCPuppet self,
    Bounty bounty
);

bool OnSetBounty(SetBountyEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnSetBounty",
    (NPCPuppet_OnSetBounty x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnSetBounty(
    NPCPuppet self,
    SetBountyEvent? evt
);

bool OnSecuritySystemAgentTrackingPlayer(SecuritySystemSupport evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnSecuritySystemAgentTrackingPlayer",
    (NPCPuppet_OnSecuritySystemAgentTrackingPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool SwitchTargetPlayerTrackedAccuracy(bool freeze) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "SwitchTargetPlayerTrackedAccuracy;Bool",
    (NPCPuppet_SwitchTargetPlayerTrackedAccuracy x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SwitchTargetPlayerTrackedAccuracy(
    NPCPuppet self,
    bool freeze
);

bool SwitchTargetPlayerTrackedAccuracy(AITargetTrackerComponent ttc, bool freeze) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "SwitchTargetPlayerTrackedAccuracy;TargetTrackerComponentBool",
    (NPCPuppet_SwitchTargetPlayerTrackedAccuracy2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SwitchTargetPlayerTrackedAccuracy2(
    NPCPuppet self,
    AITargetTrackerComponent? ttc,
    bool freeze
);

bool OnPlayerDetectionChangedEvent(sense.PlayerDetectionChangedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnPlayerDetectionChangedEvent",
    (NPCPuppet_OnPlayerDetectionChangedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnPlayerDetectionChangedEvent(
    NPCPuppet self,
    sense.PlayerDetectionChangedEvent? evt
);

void SetDetectionPercentage(float percent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SetDetectionPercentage;Float",
    (NPCPuppet_SetDetectionPercentage x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SetDetectionPercentage(
    NPCPuppet self,
    float percent
);

float GetDetectionPercentage() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetDetectionPercentage;",
    (NPCPuppet_GetDetectionPercentage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetDetectionPercentage(
    NPCPuppet self
);

void InitThreatsCurves() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "InitThreatsCurves;",
    (NPCPuppet_InitThreatsCurves x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_InitThreatsCurves(
    NPCPuppet self
);

void Kill(WeakHandle<game.Object>? instigator, bool? skipNPCDeathAnim, bool? disableNPCRagdoll) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "Kill;GameObjectBoolBool",
    (NPCPuppet_Kill x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_Kill(
    NPCPuppet self,
    WeakHandle<game.Object>? instigator,
    bool? skipNPCDeathAnim,
    bool? disableNPCRagdoll
);

bool IsDead() overrideRTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsDead;",
    (NPCPuppet_IsDead x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsDead(
    NPCPuppet self
);

void MarkForDeath() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "MarkForDeath;",
    (NPCPuppet_MarkForDeath x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_MarkForDeath(
    NPCPuppet self
);

bool IsAboutToDie() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsAboutToDie;",
    (NPCPuppet_IsAboutToDie x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsAboutToDie(
    NPCPuppet self
);

void MarkForDefeat() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "MarkForDefeat;",
    (NPCPuppet_MarkForDefeat x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_MarkForDefeat(
    NPCPuppet self
);

bool IsAboutToBeDefeated() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsAboutToBeDefeated;",
    (NPCPuppet_IsAboutToBeDefeated x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsAboutToBeDefeated(
    NPCPuppet self
);

bool IsAboutToDieOrDefeated() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsAboutToDieOrDefeated;",
    (NPCPuppet_IsAboutToDieOrDefeated x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsAboutToDieOrDefeated(
    NPCPuppet self
);

bool IsDefeatMechanicActive() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsDefeatMechanicActive;",
    (NPCPuppet_IsDefeatMechanicActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsDefeatMechanicActive(
    NPCPuppet self
);

void SetIsDefeatMechanicActive(bool isDefeatMechanicActive, bool? isInitialisation) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SetIsDefeatMechanicActive;BoolBool",
    (NPCPuppet_SetIsDefeatMechanicActive x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SetIsDefeatMechanicActive(
    NPCPuppet self,
    bool isDefeatMechanicActive,
    bool? isInitialisation
);

string GetAffiliation() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetAffiliation;",
    (NPCPuppet_GetAffiliation x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetAffiliation(
    NPCPuppet self
);

void OnGodModeChanged() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "OnGodModeChanged;",
    (NPCPuppet_OnGodModeChanged x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnGodModeChanged(
    NPCPuppet self
);

bool CanEnableRagdollComponent(bool? fromSetDeathParams) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "CanEnableRagdollComponent;Bool",
    (NPCPuppet_CanEnableRagdollComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_CanEnableRagdollComponent(
    NPCPuppet self,
    bool? fromSetDeathParams
);

bool OnDisableRagdollComponentEvent(DisableRagdollComponentEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnDisableRagdollComponentEvent",
    (NPCPuppet_OnDisableRagdollComponentEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnDisableRagdollComponentEvent(
    NPCPuppet self,
    DisableRagdollComponentEvent? evt
);

void SetDisableRagdoll(bool disableRagdoll, bool? force, bool? leaveRagdollEnabled) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SetDisableRagdoll;BoolBoolBool",
    (NPCPuppet_SetDisableRagdoll x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SetDisableRagdoll(
    NPCPuppet self,
    bool disableRagdoll,
    bool? force,
    bool? leaveRagdollEnabled
);

bool CheckStubData(game.NPCstubData data) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "CheckStubData;NPCstubData",
    (NPCPuppet_CheckStubData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_CheckStubData(
    NPCPuppet self,
    game.NPCstubData data
);

bool OnItemAddedToSlot(game.AttachmentSlotEventsItemAddedToSlot evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnItemAddedToSlot",
    (NPCPuppet_OnItemAddedToSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnItemAddedToSlot(
    NPCPuppet self,
    game.AttachmentSlotEventsItemAddedToSlot? evt
);

bool OnItemVisualsAddedToSlot(game.AttachmentSlotEventsItemVisualsAddedToSlot evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnItemVisualsAddedToSlot",
    (NPCPuppet_OnItemVisualsAddedToSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnItemVisualsAddedToSlot(
    NPCPuppet self,
    game.AttachmentSlotEventsItemVisualsAddedToSlot? evt
);

void SetWeaponFx() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SetWeaponFx;",
    (NPCPuppet_SetWeaponFx x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SetWeaponFx(
    NPCPuppet self
);

void SpawnStrongArmsFX() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SpawnStrongArmsFX;",
    (NPCPuppet_SpawnStrongArmsFX x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SpawnStrongArmsFX(
    NPCPuppet self
);

void RemoveStrongArmsFX() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "RemoveStrongArmsFX;",
    (NPCPuppet_RemoveStrongArmsFX x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_RemoveStrongArmsFX(
    NPCPuppet self
);

bool OnItemRemovedFromSlot(game.AttachmentSlotEventsItemRemovedFromSlot evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnItemRemovedFromSlot",
    (NPCPuppet_OnItemRemovedFromSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnItemRemovedFromSlot(
    NPCPuppet self,
    game.AttachmentSlotEventsItemRemovedFromSlot? evt
);

void SetAnimWrapperWeightBasedOnFaction() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SetAnimWrapperWeightBasedOnFaction;",
    (NPCPuppet_SetAnimWrapperWeightBasedOnFaction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SetAnimWrapperWeightBasedOnFaction(
    NPCPuppet self
);

void SetRandomAnimWrappersForLocomotion() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SetRandomAnimWrappersForLocomotion;",
    (NPCPuppet_SetRandomAnimWrappersForLocomotion x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SetRandomAnimWrappersForLocomotion(
    NPCPuppet self
);

bool OnDelaySetCoverNPCCurrentlyExposed(DelaySetCoverNPCCurrentlyExposed evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnDelaySetCoverNPCCurrentlyExposed",
    (NPCPuppet_OnDelaySetCoverNPCCurrentlyExposed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnDelaySetCoverNPCCurrentlyExposed(
    NPCPuppet self,
    DelaySetCoverNPCCurrentlyExposed? evt
);

bool OnSetPuppetTargetingPlayer(OnBeingTarget evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnSetPuppetTargetingPlayer",
    (NPCPuppet_OnSetPuppetTargetingPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnSetPuppetTargetingPlayer(
    NPCPuppet self,
    OnBeingTarget? evt
);

void SetPuppetTargetingPlayer(bool isTargeting) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SetPuppetTargetingPlayer;Bool",
    (NPCPuppet_SetPuppetTargetingPlayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SetPuppetTargetingPlayer(
    NPCPuppet self,
    bool isTargeting
);

bool IsPuppetTargetingPlayer() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsPuppetTargetingPlayer;",
    (NPCPuppet_IsPuppetTargetingPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsPuppetTargetingPlayer(
    NPCPuppet self
);

bool PuppetIsNotVisible() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "PuppetIsNotVisible;",
    (NPCPuppet_PuppetIsNotVisible x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_PuppetIsNotVisible(
    NPCPuppet self
);

bool OnStatusEffectApplied(game.events.ApplyStatusEffectEvent evt) overrideRTTI

Generated hook

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

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

bool ShouldDelayStatusEffectApplication(game.events.ApplyStatusEffectEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "ShouldDelayStatusEffectApplication;ApplyStatusEffectEvent",
    (NPCPuppet_ShouldDelayStatusEffectApplication x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void ProcessStatusEffectApplication(game.events.ApplyStatusEffectEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "ProcessStatusEffectApplication;ApplyStatusEffectEvent",
    (NPCPuppet_ProcessStatusEffectApplication x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void OnQuickHackEffectApplied(game.events.ApplyStatusEffectEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "OnQuickHackEffectApplied;ApplyStatusEffectEvent",
    (NPCPuppet_OnQuickHackEffectApplied x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool OnNonStealthQuickHackVictimEvent(NonStealthQuickHackVictimEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnNonStealthQuickHackVictimEvent",
    (NPCPuppet_OnNonStealthQuickHackVictimEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnNonStealthQuickHackVictimEvent(
    NPCPuppet self,
    NonStealthQuickHackVictimEvent? evt
);

void TriggerDefeatedBehavior(game.events.ApplyStatusEffectEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "TriggerDefeatedBehavior;ApplyStatusEffectEvent",
    (NPCPuppet_TriggerDefeatedBehavior x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void DelayStatusEffectApplication(game.events.ApplyStatusEffectEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "DelayStatusEffectApplication;ApplyStatusEffectEvent",
    (NPCPuppet_DelayStatusEffectApplication x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void TriggerStatusEffectBehavior(game.events.ApplyStatusEffectEvent evt, bool? alwaysTrigger, bool? checkCachedSEAnim) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "TriggerStatusEffectBehavior;ApplyStatusEffectEventBoolBool",
    (NPCPuppet_TriggerStatusEffectBehavior x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_TriggerStatusEffectBehavior(
    NPCPuppet self,
    game.events.ApplyStatusEffectEvent? evt,
    bool? alwaysTrigger,
    bool? checkCachedSEAnim
);

void SendStatusEffectSignal(float priority, CName[] tags, EAIGateSignalFlags[] flags, TDBID statusEffectID, float repeatSignalDelay, float remainingStatusEffectDuration)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SendStatusEffectSignal;Floatscript_ref<array<CName>>script_ref<array<EAIGateSignalFlags>>TweakDBIDFloatFloat",
    (NPCPuppet_SendStatusEffectSignal x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SendStatusEffectSignal(
    NPCPuppet self,
    float priority,
    CName[] tags,
    EAIGateSignalFlags[] flags,
    TDBID statusEffectID,
    float repeatSignalDelay,
    float remainingStatusEffectDuration
);

void TryRepeatStatusEffectSignal(float priority, CName[] tags, EAIGateSignalFlags[] flags, TDBID statusEffectID, float repeatSignalDelay, float remainingStatusEffectDuration)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "TryRepeatStatusEffectSignal;Floatscript_ref<array<CName>>script_ref<array<EAIGateSignalFlags>>TweakDBIDFloatFloat",
    (NPCPuppet_TryRepeatStatusEffectSignal x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_TryRepeatStatusEffectSignal(
    NPCPuppet self,
    float priority,
    CName[] tags,
    EAIGateSignalFlags[] flags,
    TDBID statusEffectID,
    float repeatSignalDelay,
    float remainingStatusEffectDuration
);

bool OnStatusEffectSignal(StatusEffectSignalEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnStatusEffectSignal",
    (NPCPuppet_OnStatusEffectSignal x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnStatusEffectSignal(
    NPCPuppet self,
    StatusEffectSignalEvent? evt
);

bool OnStatusEffectRemoved(game.events.RemoveStatusEffect evt) overrideRTTI

Generated hook

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

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

void OnQuickHackEffectRemoved(game.events.RemoveStatusEffect evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "OnQuickHackEffectRemoved;RemoveStatusEffect",
    (NPCPuppet_OnQuickHackEffectRemoved x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool OnCacheStatusEffectAnim(CacheStatusEffectAnimEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnCacheStatusEffectAnim",
    (NPCPuppet_OnCacheStatusEffectAnim x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnCacheStatusEffectAnim(
    NPCPuppet self,
    CacheStatusEffectAnimEvent? evt
);

void StopStatusEffectVFX(game.events.RemoveStatusEffect evt) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "StopStatusEffectVFX;RemoveStatusEffect",
    (NPCPuppet_StopStatusEffectVFX x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void StopStatusEffectSFX(game.events.RemoveStatusEffect evt) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "StopStatusEffectSFX;RemoveStatusEffect",
    (NPCPuppet_StopStatusEffectSFX x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool OnCacheStatusEffectFX(CacheStatusEffectFXEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnCacheStatusEffectFX",
    (NPCPuppet_OnCacheStatusEffectFX x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnCacheStatusEffectFX(
    NPCPuppet self,
    CacheStatusEffectFXEvent? evt
);

bool OnRemoveCachedStatusEffectFX(RemoveCachedStatusEffectFXEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnRemoveCachedStatusEffectFX",
    (NPCPuppet_OnRemoveCachedStatusEffectFX x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnRemoveCachedStatusEffectFX(
    NPCPuppet self,
    RemoveCachedStatusEffectFXEvent? evt
);

bool OnExplorationLeftEvent(move.ExplorationLeftEvent evt) RTTI

Generated hook

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

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

void OnSignalOnUnstoppableStateSignal(ushort signalId, bool newValue, OnUnstoppableStateSignal userData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "OnSignalOnUnstoppableStateSignal;Uint16BoolOnUnstoppableStateSignal",
    (NPCPuppet_OnSignalOnUnstoppableStateSignal x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnSignalOnUnstoppableStateSignal(
    NPCPuppet self,
    ushort signalId,
    bool newValue,
    OnUnstoppableStateSignal? userData
);

bool OnDelayedSEReactionEvent(DelayedStatusEffectApplicationEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnDelayedSEReactionEvent",
    (NPCPuppet_OnDelayedSEReactionEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnDelayedSEReactionEvent(
    NPCPuppet self,
    DelayedStatusEffectApplicationEvent? evt
);

void TriggerPendingSEEvent() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "TriggerPendingSEEvent;",
    (NPCPuppet_TriggerPendingSEEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_TriggerPendingSEEvent(
    NPCPuppet self
);

void CacheStatusEffectAppliedByPlayer(game.events.ApplyStatusEffectEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "CacheStatusEffectAppliedByPlayer;ApplyStatusEffectEvent",
    (NPCPuppet_CacheStatusEffectAppliedByPlayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

game.StatusEffect? GetLastSEAppliedByPlayer() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetLastSEAppliedByPlayer;",
    (NPCPuppet_GetLastSEAppliedByPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.StatusEffect>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetLastSEAppliedByPlayer(
    NPCPuppet self
);

void OnUncontrolledMovementStatusEffectAdded(game.events.ApplyStatusEffectEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "OnUncontrolledMovementStatusEffectAdded;ApplyStatusEffectEvent",
    (NPCPuppet_OnUncontrolledMovementStatusEffectAdded x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void OnUncontrolledMovementStatusEffectRemoved() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "OnUncontrolledMovementStatusEffectRemoved;",
    (NPCPuppet_OnUncontrolledMovementStatusEffectRemoved x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnUncontrolledMovementStatusEffectRemoved(
    NPCPuppet self
);

bool OnCheckUncontrolledMovementStatusEffectEvent(CheckUncontrolledMovementStatusEffectEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnCheckUncontrolledMovementStatusEffectEvent",
    (NPCPuppet_OnCheckUncontrolledMovementStatusEffectEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnCheckUncontrolledMovementStatusEffectEvent(
    NPCPuppet self,
    CheckUncontrolledMovementStatusEffectEvent? evt
);

bool OnCheckRagdollStateEvent(CheckPuppetRagdollStateEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnCheckRagdollStateEvent",
    (NPCPuppet_OnCheckRagdollStateEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnCheckRagdollStateEvent(
    NPCPuppet self,
    CheckPuppetRagdollStateEvent? evt
);

bool OnAnimVisibilityChangedEvent(ent.AnimVisibilityChangedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnAnimVisibilityChangedEvent",
    (NPCPuppet_OnAnimVisibilityChangedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnAnimVisibilityChangedEvent(
    NPCPuppet self,
    ent.AnimVisibilityChangedEvent? evt
);

bool CanStandUpFromRagdoll(Vector4 currentPosition) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "CanStandUpFromRagdoll;Vector4",
    (NPCPuppet_CanStandUpFromRagdoll x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_CanStandUpFromRagdoll(
    NPCPuppet self,
    Vector4 currentPosition
);

bool IsUnderneathVehicle() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsUnderneathVehicle;",
    (NPCPuppet_IsUnderneathVehicle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsUnderneathVehicle(
    NPCPuppet self
);

int GetInfluenceMapScoreInRange(Vector4 currentPosition, float range, out float scorePercentage) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetInfluenceMapScoreInRange;Vector4FloatFloat",
    (NPCPuppet_GetInfluenceMapScoreInRange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetInfluenceMapScoreInRange(
    NPCPuppet self,
    Vector4 currentPosition,
    float range,
    float scorePercentage
);

bool OnRagdollEnabledEvent(ent.RagdollNotifyEnabledEvent evt) RTTI

Generated hook

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

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

void UpdateAnimgraphRagdollState(bool isActive) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "UpdateAnimgraphRagdollState;Bool",
    (NPCPuppet_UpdateAnimgraphRagdollState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_UpdateAnimgraphRagdollState(
    NPCPuppet self,
    bool isActive
);

bool OnCheckDeadPuppetDisposedEvent(CheckDeadPuppetDisposedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnCheckDeadPuppetDisposedEvent",
    (NPCPuppet_OnCheckDeadPuppetDisposedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnCheckDeadPuppetDisposedEvent(
    NPCPuppet self,
    CheckDeadPuppetDisposedEvent? evt
);

void OnNPCThrown(WeakHandle<ent.Entity>[] nearbyCrowdNPCs) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "OnNPCThrown;array<Entity>",
    (NPCPuppet_OnNPCThrown x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnNPCThrown(
    NPCPuppet self,
    WeakHandle<ent.Entity>[] nearbyCrowdNPCs
);

bool OnRagdollImpactEvent(ent.RagdollImpactEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnRagdollImpactEvent",
    (NPCPuppet_OnRagdollImpactEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnRagdollImpactEvent(
    NPCPuppet self,
    ent.RagdollImpactEvent? evt
);

bool ShouldTripVictim(NPCPuppet victim) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "ShouldTripVictim;NPCPuppet",
    (NPCPuppet_ShouldTripVictim x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ShouldTripVictim(
    NPCPuppet self,
    NPCPuppet? victim
);

bool CanReceiveDamageFromRagdollImpacts(bool isDead, bool isDefeated, bool terminalVelocityReached, bool isHighFall) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "CanReceiveDamageFromRagdollImpacts;BoolBoolBoolBool",
    (NPCPuppet_CanReceiveDamageFromRagdollImpacts x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_CanReceiveDamageFromRagdollImpacts(
    NPCPuppet self,
    bool isDead,
    bool isDefeated,
    bool terminalVelocityReached,
    bool isHighFall
);

void SpawnRagdollBumpAttack(Vector4 position) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SpawnRagdollBumpAttack;Vector4",
    (NPCPuppet_SpawnRagdollBumpAttack x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SpawnRagdollBumpAttack(
    NPCPuppet self,
    Vector4 position
);

void SpawnRagdollFloorSplash(ent.RagdollImpactPointData evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SpawnRagdollFloorSplash;script_ref<RagdollImpactPointData>",
    (NPCPuppet_SpawnRagdollFloorSplash x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SpawnRagdollFloorSplash(
    NPCPuppet self,
    ent.RagdollImpactPointData evt
);

void SpawnRagdollSplatter(ent.RagdollImpactPointData impactData, bool isDead) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SpawnRagdollSplatter;script_ref<RagdollImpactPointData>Bool",
    (NPCPuppet_SpawnRagdollSplatter x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SpawnRagdollSplatter(
    NPCPuppet self,
    ent.RagdollImpactPointData impactData,
    bool isDead
);

bool IsPointOnStaticMesh(Vector4 position, Vector4 normal) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsPointOnStaticMesh;Vector4Vector4",
    (NPCPuppet_IsPointOnStaticMesh x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsPointOnStaticMesh(
    NPCPuppet self,
    Vector4 position,
    Vector4 normal
);

void Debug_Ragdoll() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "Debug_Ragdoll;",
    (NPCPuppet_Debug_Ragdoll x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_Debug_Ragdoll(
    NPCPuppet self
);

bool OnStartRagdollDamageEvent(StartRagdollDamageEvent inEvent) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnStartRagdollDamageEvent",
    (NPCPuppet_OnStartRagdollDamageEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnStartRagdollDamageEvent(
    NPCPuppet self,
    StartRagdollDamageEvent? inEvent
);

void OnThrownNPCRagdollImpact() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "OnThrownNPCRagdollImpact;",
    (NPCPuppet_OnThrownNPCRagdollImpact x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnThrownNPCRagdollImpact(
    NPCPuppet self
);

void SetRagdollDamageData(ent.RagdollImpactPointData ragdollImpactPointData, Vector4 currentPosition) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SetRagdollDamageData;RagdollImpactPointDataVector4",
    (NPCPuppet_SetRagdollDamageData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SetRagdollDamageData(
    NPCPuppet self,
    ent.RagdollImpactPointData ragdollImpactPointData,
    Vector4 currentPosition
);

void ResetRagdollDamageData() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "ResetRagdollDamageData;",
    (NPCPuppet_ResetRagdollDamageData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ResetRagdollDamageData(
    NPCPuppet self
);

bool GetRagdollInstigator(out WeakHandle<game.Object> ragdollInstigator) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetRagdollInstigator;GameObject",
    (NPCPuppet_GetRagdollInstigator x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetRagdollInstigator(
    NPCPuppet self,
    WeakHandle<game.Object> ragdollInstigator
);

bool OnRagdollDisabledEvent(ent.RagdollNotifyDisabledEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnRagdollDisabledEvent",
    (NPCPuppet_OnRagdollDisabledEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnRagdollDisabledEvent(
    NPCPuppet self,
    ent.RagdollNotifyDisabledEvent? evt
);

bool OnAnimatedRagdollEnabledEvent(ent.AnimatedRagdollNotifyEnabledEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnAnimatedRagdollEnabledEvent",
    (NPCPuppet_OnAnimatedRagdollEnabledEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnAnimatedRagdollEnabledEvent(
    NPCPuppet self,
    ent.AnimatedRagdollNotifyEnabledEvent? evt
);

bool IsCloseEnoughForGrandFinale(WeakHandle<game.Object> target, float maxDistance) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsCloseEnoughForGrandFinale;GameObjectFloat",
    (NPCPuppet_IsCloseEnoughForGrandFinale x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsCloseEnoughForGrandFinale(
    NPCPuppet self,
    WeakHandle<game.Object> target,
    float maxDistance
);

bool OnApplyRelicMeleewareDamageOnNPCEvent(ApplyRelicMeleewareDamageOnNPCEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnApplyRelicMeleewareDamageOnNPCEvent",
    (NPCPuppet_OnApplyRelicMeleewareDamageOnNPCEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnApplyRelicMeleewareDamageOnNPCEvent(
    NPCPuppet self,
    ApplyRelicMeleewareDamageOnNPCEvent? evt
);

void SpawnVehicleBumpAttack(WeakHandle<vehicle.BaseObject> vehicle, WeakHandle<game.Object> instigator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SpawnVehicleBumpAttack;VehicleObjectGameObject",
    (NPCPuppet_SpawnVehicleBumpAttack x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SpawnVehicleBumpAttack(
    NPCPuppet self,
    WeakHandle<vehicle.BaseObject> vehicle,
    WeakHandle<game.Object> instigator
);

bool OnAnimatedRagdollDisabledEvent(ent.AnimatedRagdollNotifyDisabledEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnAnimatedRagdollDisabledEvent",
    (NPCPuppet_OnAnimatedRagdollDisabledEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnAnimatedRagdollDisabledEvent(
    NPCPuppet self,
    ent.AnimatedRagdollNotifyDisabledEvent? evt
);

bool IsOutsideOfNavmesh(Vector4 currentPosition) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsOutsideOfNavmesh;Vector4",
    (NPCPuppet_IsOutsideOfNavmesh x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsOutsideOfNavmesh(
    NPCPuppet self,
    Vector4 currentPosition
);

bool IsOutsideOfNavmeshWithTolerance(Vector4 currentPosition, Vector4 tolerance) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsOutsideOfNavmeshWithTolerance;Vector4Vector4",
    (NPCPuppet_IsOutsideOfNavmeshWithTolerance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsOutsideOfNavmeshWithTolerance(
    NPCPuppet self,
    Vector4 currentPosition,
    Vector4 tolerance
);

bool IsOutsideOfNavmesh(Vector4 currentPosition, out Vector4 navmeshPoint) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsOutsideOfNavmesh;Vector4Vector4",
    (NPCPuppet_IsOutsideOfNavmesh2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsOutsideOfNavmesh2(
    NPCPuppet self,
    Vector4 currentPosition,
    Vector4 navmeshPoint
);

bool IsAnOccupiedInfluenceMapNode(Vector4 currentPosition) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsAnOccupiedInfluenceMapNode;Vector4",
    (NPCPuppet_IsAnOccupiedInfluenceMapNode x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsAnOccupiedInfluenceMapNode(
    NPCPuppet self,
    Vector4 currentPosition
);

void TriggerRagdollBehavior() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "TriggerRagdollBehavior;",
    (NPCPuppet_TriggerRagdollBehavior x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_TriggerRagdollBehavior(
    NPCPuppet self
);

void TriggerRagdollBehaviorEnd() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "TriggerRagdollBehaviorEnd;",
    (NPCPuppet_TriggerRagdollBehaviorEnd x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_TriggerRagdollBehaviorEnd(
    NPCPuppet self
);

bool IsRagdolling() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsRagdolling;",
    (NPCPuppet_IsRagdolling x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsRagdolling(
    NPCPuppet self
);

bool IsRagdollEnabled() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsRagdollEnabled;",
    (NPCPuppet_IsRagdollEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsRagdollEnabled(
    NPCPuppet self
);

Vector4 GetInitialRagdollPosition() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetInitialRagdollPosition;",
    (NPCPuppet_GetInitialRagdollPosition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetInitialRagdollPosition(
    NPCPuppet self
);

bool KillIfUnderwater() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "KillIfUnderwater;",
    (NPCPuppet_KillIfUnderwater x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_KillIfUnderwater(
    NPCPuppet self
);

bool HasHeadUnderwater() overrideRTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "HasHeadUnderwater;",
    (NPCPuppet_HasHeadUnderwater x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_HasHeadUnderwater(
    NPCPuppet self
);

bool OnRagdollBodyPartWaterImpactEvent(ent.RagdollBodyPartWaterImpactEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnRagdollBodyPartWaterImpactEvent",
    (NPCPuppet_OnRagdollBodyPartWaterImpactEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnRagdollBodyPartWaterImpactEvent(
    NPCPuppet self,
    ent.RagdollBodyPartWaterImpactEvent? evt
);

bool OnAttitudeChanged(game.events.AttitudeChangedEvent evt) overrideRTTI

Generated hook

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

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

bool OnHit(game.events.HitEvent evt) overrideRTTI

Generated hook

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

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

void DamagePipelineFinalized(game.events.HitEvent evt) overrideRTTI

Generated hook

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

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

bool OnScanningLookedAt(game.ScanningLookAtEvent evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnScanningLookedAt",
    (NPCPuppet_OnScanningLookedAt x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnScanningLookedAt(
    NPCPuppet self,
    game.ScanningLookAtEvent? evt
);

bool OnRevealStateChanged(RevealStateChangedEvent evt) overrideRTTI

Generated hook

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

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

void SendRevealStateToAllWeakspots(ERevealState revealState) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SendRevealStateToAllWeakspots;ERevealState",
    (NPCPuppet_SendRevealStateToAllWeakspots x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SendRevealStateToAllWeakspots(
    NPCPuppet self,
    ERevealState revealState
);

bool OnSetupWorkspotActionEvent(game.SetupWorkspotActionEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnSetupWorkspotActionEvent",
    (NPCPuppet_OnSetupWorkspotActionEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnSetupWorkspotActionEvent(
    NPCPuppet self,
    game.SetupWorkspotActionEvent? evt
);

void SetHitEventData(game.events.HitEvent hitEvent, float hitReactionFactor, float hitWoundsFactor, float hitDismembermentFactor)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SetHitEventData;gameHitEventFloatFloatFloat",
    (NPCPuppet_SetHitEventData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SetHitEventData(
    NPCPuppet self,
    game.events.HitEvent? hitEvent,
    float hitReactionFactor,
    float hitWoundsFactor,
    float hitDismembermentFactor
);

void OnHitAnimation(game.events.HitEvent hitEvent) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "OnHitAnimation;gameHitEvent",
    (NPCPuppet_OnHitAnimation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnHitAnimation(
    NPCPuppet self,
    game.events.HitEvent? hitEvent
);

bool OnResetAttackBlockedBlackBoardValue(ResetAttackBlockedBlackBoardValue evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnResetAttackBlockedBlackBoardValue",
    (NPCPuppet_OnResetAttackBlockedBlackBoardValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnResetAttackBlockedBlackBoardValue(
    NPCPuppet self,
    ResetAttackBlockedBlackBoardValue? evt
);

bool ShouldRequestHitReaction(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "ShouldRequestHitReaction;gameHitEvent",
    (NPCPuppet_ShouldRequestHitReaction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ShouldRequestHitReaction(
    NPCPuppet self,
    game.events.HitEvent? hitEvent
);

void RequestHitReaction(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "RequestHitReaction;gameHitEvent",
    (NPCPuppet_RequestHitReaction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_RequestHitReaction(
    NPCPuppet self,
    game.events.HitEvent? hitEvent
);

void OnHitSounds(game.events.HitEvent hitEvent) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "OnHitSounds;gameHitEvent",
    (NPCPuppet_OnHitSounds x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnHitSounds(
    NPCPuppet self,
    game.events.HitEvent? hitEvent
);

float GetTotalFrameDamage() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetTotalFrameDamage;",
    (NPCPuppet_GetTotalFrameDamage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetTotalFrameDamage(
    NPCPuppet self
);

float GetTotalFrameWoundsDamage() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetTotalFrameWoundsDamage;",
    (NPCPuppet_GetTotalFrameWoundsDamage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetTotalFrameWoundsDamage(
    NPCPuppet self
);

float GetTotalFrameDismembermentDamage() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetTotalFrameDismembermentDamage;",
    (NPCPuppet_GetTotalFrameDismembermentDamage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetTotalFrameDismembermentDamage(
    NPCPuppet self
);

bool OnResetTotalFrameDamage(ResetFrameDamage evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnResetTotalFrameDamage",
    (NPCPuppet_OnResetTotalFrameDamage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnResetTotalFrameDamage(
    NPCPuppet self,
    ResetFrameDamage? evt
);

game.data.AttackType GetLastHitAttackType() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetLastHitAttackType;",
    (NPCPuppet_GetLastHitAttackType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AttackType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetLastHitAttackType(
    NPCPuppet self
);

WeakHandle<game.Object> GetLastHitInstigator() RTTI

game.data.Attack_GameEffect_Record? GetLastHitAttackRecord() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetLastHitAttackRecord;",
    (NPCPuppet_GetLastHitAttackRecord x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Attack_GameEffect_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetLastHitAttackRecord(
    NPCPuppet self
);

bool HasLastHitFlag(hitFlag flag) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "HasLastHitFlag;hitFlag",
    (NPCPuppet_HasLastHitFlag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_HasLastHitFlag(
    NPCPuppet self,
    hitFlag flag
);

float[] GetLastHitAttackValues() RTTI

Vector4 GetLastHitAttackDirection() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetLastHitAttackDirection;",
    (NPCPuppet_GetLastHitAttackDirection x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetLastHitAttackDirection(
    NPCPuppet self
);

void OnHitUI(game.events.HitEvent hitEvent) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "OnHitUI;gameHitEvent",
    (NPCPuppet_OnHitUI x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnHitUI(
    NPCPuppet self,
    game.events.HitEvent? hitEvent
);

bool WasJustKilledOrDefeated() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "WasJustKilledOrDefeated;",
    (NPCPuppet_WasJustKilledOrDefeated x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_WasJustKilledOrDefeated(
    NPCPuppet self
);

void SendAfterDeathOrDefeatEvent() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SendAfterDeathOrDefeatEvent;",
    (NPCPuppet_SendAfterDeathOrDefeatEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SendAfterDeathOrDefeatEvent(
    NPCPuppet self
);

void SendDataTrackingEvent(bool defeated, bool nonLethal) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SendDataTrackingEvent;BoolBool",
    (NPCPuppet_SendDataTrackingEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SendDataTrackingEvent(
    NPCPuppet self,
    bool defeated,
    bool nonLethal
);

bool OnAfterDeathOrDefeat(NPCAfterDeathOrDefeatEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnAfterDeathOrDefeat",
    (NPCPuppet_OnAfterDeathOrDefeat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnAfterDeathOrDefeat(
    NPCPuppet self,
    NPCAfterDeathOrDefeatEvent? evt
);

void ClearDefeatAndImmortality() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "ClearDefeatAndImmortality;",
    (NPCPuppet_ClearDefeatAndImmortality x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ClearDefeatAndImmortality(
    NPCPuppet self
);

bool OnResetTimeDilation(ResetTimeDilation evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnResetTimeDilation",
    (NPCPuppet_OnResetTimeDilation x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnResetTimeDilation(
    NPCPuppet self,
    ResetTimeDilation? evt
);

bool OnDeath(game.events.DeathEvent evt) overrideRTTI

Generated hook

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

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

void TrySetPreventionCodeRedReinforcement() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "TrySetPreventionCodeRedReinforcement;",
    (NPCPuppet_TrySetPreventionCodeRedReinforcement x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_TrySetPreventionCodeRedReinforcement(
    NPCPuppet self
);

void EvaluateQuickHackPassivesIncapacitated() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "EvaluateQuickHackPassivesIncapacitated;",
    (NPCPuppet_EvaluateQuickHackPassivesIncapacitated x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_EvaluateQuickHackPassivesIncapacitated(
    NPCPuppet self
);

bool OnPotentialDeath(game.events.PotentialDeathEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnPotentialDeath",
    (NPCPuppet_OnPotentialDeath x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnPotentialDeath(
    NPCPuppet self,
    game.events.PotentialDeathEvent? evt
);

bool OnFinisherEffectorActionOn(FinisherEffectorActionOn evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnFinisherEffectorActionOn",
    (NPCPuppet_OnFinisherEffectorActionOn x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnFinisherEffectorActionOn(
    NPCPuppet self,
    FinisherEffectorActionOn? evt
);

bool SearchForNonlethalFlag() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "SearchForNonlethalFlag;",
    (NPCPuppet_SearchForNonlethalFlag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SearchForNonlethalFlag(
    NPCPuppet self
);

bool GetValidAttackFromDamageHistory(DamageHistoryEntry entry) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetValidAttackFromDamageHistory;script_ref<DamageHistoryEntry>",
    (NPCPuppet_GetValidAttackFromDamageHistory x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetValidAttackFromDamageHistory(
    NPCPuppet self,
    DamageHistoryEntry entry
);

void ProcessDoTAttackData() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "ProcessDoTAttackData;",
    (NPCPuppet_ProcessDoTAttackData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ProcessDoTAttackData(
    NPCPuppet self
);

void UpdateCollisionState(bool? onRagdollDisabled) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "UpdateCollisionState;Bool",
    (NPCPuppet_UpdateCollisionState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_UpdateCollisionState(
    NPCPuppet self,
    bool? onRagdollDisabled
);

void DisableCollision() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "DisableCollision;",
    (NPCPuppet_DisableCollision x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_DisableCollision(
    NPCPuppet self
);

void EnableCollision() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "EnableCollision;",
    (NPCPuppet_EnableCollision x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_EnableCollision(
    NPCPuppet self
);

void OnDefeatedWithRecoverStatusEffectApplied() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "OnDefeatedWithRecoverStatusEffectApplied;",
    (NPCPuppet_OnDefeatedWithRecoverStatusEffectApplied x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnDefeatedWithRecoverStatusEffectApplied(
    NPCPuppet self
);

void OnDefeatedWithRecoverStatusEffectRemoved() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "OnDefeatedWithRecoverStatusEffectRemoved;",
    (NPCPuppet_OnDefeatedWithRecoverStatusEffectRemoved x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnDefeatedWithRecoverStatusEffectRemoved(
    NPCPuppet self
);

void OnResurrected() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "OnResurrected;",
    (NPCPuppet_OnResurrected x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnResurrected(
    NPCPuppet self
);

void OnIncapacitated() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "OnIncapacitated;",
    (NPCPuppet_OnIncapacitated x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnIncapacitated(
    NPCPuppet self
);

void HandleRagdollOnDeathByEvent(bool handleUncontrolledMovement) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "HandleRagdollOnDeathByEvent;Bool",
    (NPCPuppet_HandleRagdollOnDeathByEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_HandleRagdollOnDeathByEvent(
    NPCPuppet self,
    bool handleUncontrolledMovement
);

bool OnHandleRagdollOnDeath(HandleRagdollOnDeathEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnHandleRagdollOnDeath",
    (NPCPuppet_OnHandleRagdollOnDeath x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnHandleRagdollOnDeath(
    NPCPuppet self,
    HandleRagdollOnDeathEvent? evt
);

void HandleRagdollOnDeath(bool handleUncontrolledMovement) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "HandleRagdollOnDeath;Bool",
    (NPCPuppet_HandleRagdollOnDeath x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_HandleRagdollOnDeath(
    NPCPuppet self,
    bool handleUncontrolledMovement
);

bool IsFloorSteepEnoughToRagdoll() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsFloorSteepEnoughToRagdoll;",
    (NPCPuppet_IsFloorSteepEnoughToRagdoll x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsFloorSteepEnoughToRagdoll(
    NPCPuppet self
);

void ProcessAndroidIncapacitated() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "ProcessAndroidIncapacitated;",
    (NPCPuppet_ProcessAndroidIncapacitated x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ProcessAndroidIncapacitated(
    NPCPuppet self
);

bool IsIncapacitated() overrideRTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsIncapacitated;",
    (NPCPuppet_IsIncapacitated x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsIncapacitated(
    NPCPuppet self
);

void ReevaluateQuickHackPerkRewardsForPlayer() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "ReevaluateQuickHackPerkRewardsForPlayer;",
    (NPCPuppet_ReevaluateQuickHackPerkRewardsForPlayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ReevaluateQuickHackPerkRewardsForPlayer(
    NPCPuppet self
);

bool OnVehicleHijackEvent(VehicleHijackEvent evt) RTTI

Generated hook

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

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

bool OnResetVehicleHijackEvent(ResetVehicleHijackEvent evt) RTTI

Generated hook

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

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

bool OnVehicleHackedEvent(VehicleHackedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnVehicleHackedEvent",
    (NPCPuppet_OnVehicleHackedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnVehicleHackedEvent(
    NPCPuppet self,
    VehicleHackedEvent? evt
);

bool OnVehicleRammedEvent(VehicleRammedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnVehicleRammedEvent",
    (NPCPuppet_OnVehicleRammedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnVehicleRammedEvent(
    NPCPuppet self,
    VehicleRammedEvent? evt
);

bool OnCoverHit(game.events.CoverHitEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnCoverHit",
    (NPCPuppet_OnCoverHit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnCoverHit(
    NPCPuppet self,
    game.events.CoverHitEvent? evt
);

void OnHitVFX(game.events.HitEvent hitEvent) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "OnHitVFX;gameHitEvent",
    (NPCPuppet_OnHitVFX x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnHitVFX(
    NPCPuppet self,
    game.events.HitEvent? hitEvent
);

void PlayImpactSound() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "PlayImpactSound;",
    (NPCPuppet_PlayImpactSound x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_PlayImpactSound(
    NPCPuppet self
);

void SpawnHitVisualEffect(CName n) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SpawnHitVisualEffect;CName",
    (NPCPuppet_SpawnHitVisualEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SpawnHitVisualEffect(
    NPCPuppet self,
    CName n
);

bool CompileScannerChunks() overrideRTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "CompileScannerChunks;",
    (NPCPuppet_CompileScannerChunks x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_CompileScannerChunks(
    NPCPuppet self
);

bool OnSetExposeQuickHacks(SetExposeQuickHacks evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnSetExposeQuickHacks",
    (NPCPuppet_OnSetExposeQuickHacks x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnSetExposeQuickHacks(
    NPCPuppet self,
    SetExposeQuickHacks? evt
);

bool OnSmartBulletDeflectedEvent(SmartBulletDeflectedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnSmartBulletDeflectedEvent",
    (NPCPuppet_OnSmartBulletDeflectedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnSmartBulletDeflectedEvent(
    NPCPuppet self,
    SmartBulletDeflectedEvent? evt
);

void UpdateAdditionalScanningData() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "UpdateAdditionalScanningData;",
    (NPCPuppet_UpdateAdditionalScanningData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_UpdateAdditionalScanningData(
    NPCPuppet self
);

game.data.DamageType GetHighestDamageStat(game.ItemData item) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetHighestDamageStat;gameItemData",
    (NPCPuppet_GetHighestDamageStat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.DamageType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetHighestDamageStat(
    NPCPuppet self,
    game.ItemData? item
);

void MountingStartDisableComponents() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "MountingStartDisableComponents;",
    (NPCPuppet_MountingStartDisableComponents x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_MountingStartDisableComponents(
    NPCPuppet self
);

void MountingEndEnableComponents() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "MountingEndEnableComponents;",
    (NPCPuppet_MountingEndEnableComponents x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_MountingEndEnableComponents(
    NPCPuppet self
);

void GrappleTargetDeadEnableRagdollComponent(bool b) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "GrappleTargetDeadEnableRagdollComponent;Bool",
    (NPCPuppet_GrappleTargetDeadEnableRagdollComponent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GrappleTargetDeadEnableRagdollComponent(
    NPCPuppet self,
    bool b
);

void SetMyKiller(game.Object killer) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SetMyKiller;GameObject",
    (NPCPuppet_SetMyKiller x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SetMyKiller(
    NPCPuppet self,
    game.Object? killer
);

bool OnGrappleTargetDeadEnableRagdollWithDelay(RagdollToggleDelayEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnGrappleTargetDeadEnableRagdollWithDelay",
    (NPCPuppet_OnGrappleTargetDeadEnableRagdollWithDelay x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnGrappleTargetDeadEnableRagdollWithDelay(
    NPCPuppet self,
    RagdollToggleDelayEvent? evt
);

bool OnHidePuppetDelayEvent(HidePuppetDelayEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnHidePuppetDelayEvent",
    (NPCPuppet_OnHidePuppetDelayEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnHidePuppetDelayEvent(
    NPCPuppet self,
    HidePuppetDelayEvent? evt
);

bool On_TEMP_TestNPCOutsideNavmeshEvent(TestNPCOutsideNavmeshEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "On_TEMP_TestNPCOutsideNavmeshEvent",
    (NPCPuppet_On_TEMP_TestNPCOutsideNavmeshEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_On_TEMP_TestNPCOutsideNavmeshEvent(
    NPCPuppet self,
    TestNPCOutsideNavmeshEvent? evt
);

ScavengeComponent? GetScavengeComponent() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetScavengeComponent;",
    (NPCPuppet_GetScavengeComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ScavengeComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetScavengeComponent(
    NPCPuppet self
);

game.influence.Component? GetInfluenceComponent() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetInfluenceComponent;",
    (NPCPuppet_GetInfluenceComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.influence.GameInfluenceComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetInfluenceComponent(
    NPCPuppet self
);

ent.IComponent? GetComfortZoneComponent() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetComfortZoneComponent;",
    (NPCPuppet_GetComfortZoneComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.IComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetComfortZoneComponent(
    NPCPuppet self
);

bool OnSetDeathParams(game.events.DeathParamsEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnSetDeathParams",
    (NPCPuppet_OnSetDeathParams x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnSetDeathParams(
    NPCPuppet self,
    game.events.DeathParamsEvent? evt
);

bool OnSetDeathDirection(game.events.DeathDirectionEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnSetDeathDirection",
    (NPCPuppet_OnSetDeathDirection x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnSetDeathDirection(
    NPCPuppet self,
    game.events.DeathDirectionEvent? evt
);

bool IsRipperdoc() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "IsRipperdoc;",
    (NPCPuppet_IsRipperdoc x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsRipperdoc(
    NPCPuppet self
);

void RegisterCallbacks() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "RegisterCallbacks;",
    (NPCPuppet_RegisterCallbacks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_RegisterCallbacks(
    NPCPuppet self
);

void RegisterCallbacksForReactions() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "RegisterCallbacksForReactions;",
    (NPCPuppet_RegisterCallbacksForReactions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_RegisterCallbacksForReactions(
    NPCPuppet self
);

void UnregisterCallbacksForReactions() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "UnregisterCallbacksForReactions;",
    (NPCPuppet_UnregisterCallbacksForReactions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_UnregisterCallbacksForReactions(
    NPCPuppet self
);

bool OnLookedAtEvent(LookedAtEvent evt) overrideRTTI

Generated hook

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

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

void ResolveReactiOnLookedAt(bool isLookedAt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "ResolveReactiOnLookedAt;Bool",
    (NPCPuppet_ResolveReactiOnLookedAt x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ResolveReactiOnLookedAt(
    NPCPuppet self,
    bool isLookedAt
);

bool OnQuestOverrideScannerPreset(OverrideScannerPreset evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnQuestOverrideScannerPreset",
    (NPCPuppet_OnQuestOverrideScannerPreset x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnQuestOverrideScannerPreset(
    NPCPuppet self,
    OverrideScannerPreset? evt
);

bool OnQuestResetScannerPreset(ResetScannerPreset evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnQuestResetScannerPreset",
    (NPCPuppet_OnQuestResetScannerPreset x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnQuestResetScannerPreset(
    NPCPuppet self,
    ResetScannerPreset? evt
);

bool OnAimedAt(int value) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnAimedAt",
    (NPCPuppet_OnAimedAt x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnAimedAt(
    NPCPuppet self,
    int value
);

bool OnCyberware(int value) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnCyberware",
    (NPCPuppet_OnCyberware x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnCyberware(
    NPCPuppet self,
    int value
);

bool OnMelee(int value) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnMelee",
    (NPCPuppet_OnMelee x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnMelee(
    NPCPuppet self,
    int value
);

bool OnCombatGadget(int value) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnCombatGadget",
    (NPCPuppet_OnCombatGadget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnCombatGadget(
    NPCPuppet self,
    int value
);

bool OnNPCStartThrowingGrenadeEvent(NPCThrowingGrenadeEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnNPCStartThrowingGrenadeEvent",
    (NPCPuppet_OnNPCStartThrowingGrenadeEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnNPCStartThrowingGrenadeEvent(
    NPCPuppet self,
    NPCThrowingGrenadeEvent? evt
);

void PlayVOOnSquadMembers(bool instigatorIsPlayer) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "PlayVOOnSquadMembers;Bool",
    (NPCPuppet_PlayVOOnSquadMembers x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_PlayVOOnSquadMembers(
    NPCPuppet self,
    bool instigatorIsPlayer
);

void PlayVOOnPlayerOrPlayerCompanion(game.Object instigator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "PlayVOOnPlayerOrPlayerCompanion;GameObject",
    (NPCPuppet_PlayVOOnPlayerOrPlayerCompanion x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void CheckNPCKilledThrowingGrenade(game.Object instigator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "CheckNPCKilledThrowingGrenade;GameObject",
    (NPCPuppet_CheckNPCKilledThrowingGrenade x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool CanGoThroughDoors() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "CanGoThroughDoors;",
    (NPCPuppet_CanGoThroughDoors x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_CanGoThroughDoors(
    NPCPuppet self
);

bool OnEnteredPathWithDoors(EnteredPathWithDoors evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnEnteredPathWithDoors",
    (NPCPuppet_OnEnteredPathWithDoors x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnEnteredPathWithDoors(
    NPCPuppet self,
    EnteredPathWithDoors? evt
);

bool OnFinishedPathWithDoors(FinishedPathWithDoors evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnFinishedPathWithDoors",
    (NPCPuppet_OnFinishedPathWithDoors x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnFinishedPathWithDoors(
    NPCPuppet self,
    FinishedPathWithDoors? evt
);

bool OnEnteredSplineEvent(move.EnteredSplineEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnEnteredSplineEvent",
    (NPCPuppet_OnEnteredSplineEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnEnteredSplineEvent(
    NPCPuppet self,
    move.EnteredSplineEvent? evt
);

bool OnExitedSplineEvent(move.ExitedSplineEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnExitedSplineEvent",
    (NPCPuppet_OnExitedSplineEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnExitedSplineEvent(
    NPCPuppet self,
    move.ExitedSplineEvent? evt
);

WeakHandle<game.Object> GetMyKiller() RTTI

EAIThreatCalculationType GetThreatCalculationType() RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetThreatCalculationType;",
    (NPCPuppet_GetThreatCalculationType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EAIThreatCalculationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetThreatCalculationType(
    NPCPuppet self
);

void ReevaluatEAIThreatCalculationType() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "ReevaluatEAIThreatCalculationType;",
    (NPCPuppet_ReevaluatEAIThreatCalculationType x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ReevaluatEAIThreatCalculationType(
    NPCPuppet self
);

bool OnAIThreatCalculationEvent(AIThreatCalculationEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnAIThreatCalculationEvent",
    (NPCPuppet_OnAIThreatCalculationEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnAIThreatCalculationEvent(
    NPCPuppet self,
    AIThreatCalculationEvent? evt
);

void OnHittingPlayer(WeakHandle<game.Object> playerPuppet, float damageInflicted) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "OnHittingPlayer;GameObjectFloat",
    (NPCPuppet_OnHittingPlayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnHittingPlayer(
    NPCPuppet self,
    WeakHandle<game.Object> playerPuppet,
    float damageInflicted
);

bool OnSmartDespawnRequest(SmartDespawnRequest evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnSmartDespawnRequest",
    (NPCPuppet_OnSmartDespawnRequest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnSmartDespawnRequest(
    NPCPuppet self,
    SmartDespawnRequest? evt
);

bool OnCancelSmartDespawnRequest(CancelSmartDespawnRequest evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnCancelSmartDespawnRequest",
    (NPCPuppet_OnCancelSmartDespawnRequest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnCancelSmartDespawnRequest(
    NPCPuppet self,
    CancelSmartDespawnRequest? evt
);

bool OnUnregisterAggressiveCrowd(UnregisterAggressiveCrowd evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnUnregisterAggressiveCrowd",
    (NPCPuppet_OnUnregisterAggressiveCrowd x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnUnregisterAggressiveCrowd(
    NPCPuppet self,
    UnregisterAggressiveCrowd? evt
);

bool OnCleanUpThrownNPCNearbyCrowdNPCs(CleanUpThrownNPCNearbyCrowdNPCs evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnCleanUpThrownNPCNearbyCrowdNPCs",
    (NPCPuppet_OnCleanUpThrownNPCNearbyCrowdNPCs x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnCleanUpThrownNPCNearbyCrowdNPCs(
    NPCPuppet self,
    CleanUpThrownNPCNearbyCrowdNPCs? evt
);

void SetWasAggressiveCrowd(bool wasAggressive) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "SetWasAggressiveCrowd;Bool",
    (NPCPuppet_SetWasAggressiveCrowd x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SetWasAggressiveCrowd(
    NPCPuppet self,
    bool wasAggressive
);

bool GetWasAggressiveCrowd() overrideRTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "GetWasAggressiveCrowd;",
    (NPCPuppet_GetWasAggressiveCrowd x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetWasAggressiveCrowd(
    NPCPuppet self
);

void CallUnregisterAggressiveNPC() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "CallUnregisterAggressiveNPC;",
    (NPCPuppet_CallUnregisterAggressiveNPC x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_CallUnregisterAggressiveNPC(
    NPCPuppet self
);

void UnregisterAggressiveNPC() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "UnregisterAggressiveNPC;",
    (NPCPuppet_UnregisterAggressiveNPC x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_UnregisterAggressiveNPC(
    NPCPuppet self
);

void ForceReEvaluateGameplayRole() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "ForceReEvaluateGameplayRole;",
    (NPCPuppet_ForceReEvaluateGameplayRole x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ForceReEvaluateGameplayRole(
    NPCPuppet self
);

bool OnResetNPCHitReactionTypePrereqStateEvent(ResetNPCHitReactionTypePrereqStateEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "OnResetNPCHitReactionTypePrereqStateEvent",
    (NPCPuppet_OnResetNPCHitReactionTypePrereqStateEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_OnResetNPCHitReactionTypePrereqStateEvent(
    NPCPuppet self,
    ResetNPCHitReactionTypePrereqStateEvent? evt
);

static bool IsInAlerted(WeakHandle<ScriptedPuppet> npc) staticRTTI global

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "NPCPuppet::IsInAlerted;ScriptedPuppet",
    (NPCPuppet_IsInAlerted x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static void ChangeLocomotionMode(game.Object obj, game.data.LocomotionMode newState) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "NPCPuppet::ChangeLocomotionMode;GameObjectgamedataLocomotionMode",
    (NPCPuppet_ChangeLocomotionMode x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ChangeLocomotionMode(
    game.Object? obj,
    game.data.LocomotionMode newState
);

static bool IsUnstoppable(WeakHandle<ScriptedPuppet> npc) staticRTTI global

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "NPCPuppet::IsUnstoppable;ScriptedPuppet",
    (NPCPuppet_IsUnstoppable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static void ChangeHighLevelState(game.Object obj, game.data.NPCHighLevelState newState) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "NPCPuppet::ChangeHighLevelState;GameObjectgamedataNPCHighLevelState",
    (NPCPuppet_ChangeHighLevelState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ChangeHighLevelState(
    game.Object? obj,
    game.data.NPCHighLevelState newState
);

static void ChangeUpperBodyState(game.Object obj, game.data.NPCUpperBodyState newState) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "NPCPuppet::ChangeUpperBodyState;GameObjectgamedataNPCUpperBodyState",
    (NPCPuppet_ChangeUpperBodyState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ChangeUpperBodyState(
    game.Object? obj,
    game.data.NPCUpperBodyState newState
);

static void RemoveTemporaryThreatCalculationType(WeakHandle<game.Object> npc) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "NPCPuppet::RemoveTemporaryThreatCalculationType;GameObject",
    (NPCPuppet_RemoveTemporaryThreatCalculationType x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static void ChangePhaseState(game.Object obj, ENPCPhaseState newState) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "NPCPuppet::ChangePhaseState;GameObjectENPCPhaseState",
    (NPCPuppet_ChangePhaseState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ChangePhaseState(
    game.Object? obj,
    ENPCPhaseState newState
);

static void SendNPCHitDataTrackingRequest(NPCPuppet owner, ENPCTelemetryData telemetryData, int modifyValue) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "NPCPuppet::SendNPCHitDataTrackingRequest;NPCPuppetENPCTelemetryDataInt32",
    (NPCPuppet_SendNPCHitDataTrackingRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SendNPCHitDataTrackingRequest(
    NPCPuppet? owner,
    ENPCTelemetryData telemetryData,
    int modifyValue
);

static void SetTemporaryThreatCalculationType(WeakHandle<game.Object> npc, EAIThreatCalculationType newType) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "NPCPuppet::SetTemporaryThreatCalculationType;GameObjectEAIThreatCalculationType",
    (NPCPuppet_SetTemporaryThreatCalculationType x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SetTemporaryThreatCalculationType(
    WeakHandle<game.Object> npc,
    EAIThreatCalculationType newType
);

static void SetAnimWrapperBasedOnEquippedItem(WeakHandle<NPCPuppet> npc, TDBID slotID, game.ItemID itemID, float value) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "NPCPuppet::SetAnimWrapperBasedOnEquippedItem;NPCPuppetTweakDBIDItemIDFloat",
    (NPCPuppet_SetAnimWrapperBasedOnEquippedItem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SetAnimWrapperBasedOnEquippedItem(
    WeakHandle<NPCPuppet> npc,
    TDBID slotID,
    game.ItemID itemID,
    float value
);

static void SetBountyObject(game.Object target, Bounty bounty) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "NPCPuppet::SetBountyObject;GameObjectscript_ref<Bounty>",
    (NPCPuppet_SetBountyObject x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SetBountyObject(
    game.Object? target,
    Bounty bounty
);

static TDBID GetMantisBladesNPCMarkStatusEffectID() staticRTTI global

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "NPCPuppet::GetMantisBladesNPCMarkStatusEffectID;",
    (NPCPuppet_GetMantisBladesNPCMarkStatusEffectID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetMantisBladesNPCMarkStatusEffectID();

static bool RevealPlayerPositionIfNeeded(WeakHandle<ScriptedPuppet> ownerPuppet, ent.EntityID playerID, bool isPrevention)

staticRTTI global

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "NPCPuppet::RevealPlayerPositionIfNeeded;ScriptedPuppetEntityIDBool",
    (NPCPuppet_RevealPlayerPositionIfNeeded x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_RevealPlayerPositionIfNeeded(
    WeakHandle<ScriptedPuppet> ownerPuppet,
    ent.EntityID playerID,
    bool isPrevention
);

static void ChangeDefenseModeState(game.Object obj, game.data.DefenseMode newState) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "NPCPuppet::ChangeDefenseModeState;GameObjectgamedataDefenseMode",
    (NPCPuppet_ChangeDefenseModeState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ChangeDefenseModeState(
    game.Object? obj,
    game.data.DefenseMode newState
);

static bool ShouldShowIndicator(game.Object npc) staticRTTI global

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "NPCPuppet::ShouldShowIndicator;GameObject",
    (NPCPuppet_ShouldShowIndicator x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ShouldShowIndicator(
    game.Object? npc
);

static bool IsSusceptibleOnlyToStaggerAndHigher(WeakHandle<ScriptedPuppet> npc) staticRTTI global

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "NPCPuppet::IsSusceptibleOnlyToStaggerAndHigher;ScriptedPuppet",
    (NPCPuppet_IsSusceptibleOnlyToStaggerAndHigher x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static void TutorialAddIllegalActionFact(NPCPuppet targetPuppet) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "NPCPuppet::TutorialAddIllegalActionFact;NPCPuppet",
    (NPCPuppet_TutorialAddIllegalActionFact x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_TutorialAddIllegalActionFact(
    NPCPuppet? targetPuppet
);

static bool IsInCombatWithTarget(WeakHandle<ScriptedPuppet> npc, ent.Entity target) staticRTTI global

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "NPCPuppet::IsInCombatWithTarget;ScriptedPuppetEntity",
    (NPCPuppet_IsInCombatWithTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_IsInCombatWithTarget(
    WeakHandle<ScriptedPuppet> npc,
    ent.Entity? target
);

static TDBID GetGorillaArmsOnePunchNPCMarkStatusEffectID() staticRTTI global

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "NPCPuppet::GetGorillaArmsOnePunchNPCMarkStatusEffectID;",
    (NPCPuppet_GetGorillaArmsOnePunchNPCMarkStatusEffectID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_GetGorillaArmsOnePunchNPCMarkStatusEffectID();

static bool TargetIsHumanTrashToElite(ScriptedPuppet target) staticRTTI global

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "NPCPuppet::TargetIsHumanTrashToElite;ScriptedPuppet",
    (NPCPuppet_TargetIsHumanTrashToElite x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_TargetIsHumanTrashToElite(
    ScriptedPuppet? target
);

static void SetNPCDisposedFact(WeakHandle<NPCPuppet> npcBody) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "NPCPuppet::SetNPCDisposedFact;NPCPuppet",
    (NPCPuppet_SetNPCDisposedFact x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SetNPCDisposedFact(
    WeakHandle<NPCPuppet> npcBody
);

static void ChangeForceRagdollOnDeath(game.Object obj, bool value) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "NPCPuppet::ChangeForceRagdollOnDeath;GameObjectBool",
    (NPCPuppet_ChangeForceRagdollOnDeath x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ChangeForceRagdollOnDeath(
    game.Object? obj,
    bool value
);

static void FinisherEffectorActionOn(WeakHandle<NPCPuppet> npc, WeakHandle<game.Object> instigator) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "NPCPuppet::FinisherEffectorActionOn;NPCPuppetGameObject",
    (NPCPuppet_FinisherEffectorActionOn x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_FinisherEffectorActionOn(
    WeakHandle<NPCPuppet> npc,
    WeakHandle<game.Object> instigator
);

static void ChangeStanceState(game.Object obj, game.data.NPCStanceState newState) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "NPCPuppet::ChangeStanceState;GameObjectgamedataNPCStanceState",
    (NPCPuppet_ChangeStanceState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ChangeStanceState(
    game.Object? obj,
    game.data.NPCStanceState newState
);

static void SetAnimWrapperBasedOnEquippedItem(WeakHandle<NPCPuppet> npc, CName wrapperNameBasedOnID, TDBID slotID, game.ItemID itemID, float value)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "NPCPuppet::SetAnimWrapperBasedOnEquippedItem;NPCPuppetCNameTweakDBIDItemIDFloat",
    (NPCPuppet_SetAnimWrapperBasedOnEquippedItem2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_SetAnimWrapperBasedOnEquippedItem2(
    WeakHandle<NPCPuppet> npc,
    CName wrapperNameBasedOnID,
    TDBID slotID,
    game.ItemID itemID,
    float value
);

static void ChangeHitReactionModeState(game.Object obj, EHitReactionMode newState) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "NPCPuppet::ChangeHitReactionModeState;GameObjectEHitReactionMode",
    (NPCPuppet_ChangeHitReactionModeState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ChangeHitReactionModeState(
    game.Object? obj,
    EHitReactionMode newState
);

static bool IsInCombat(WeakHandle<ScriptedPuppet> npc) staticRTTI global

Generated hook

re.Hooks.Place(
    "NPCPuppet",
    "NPCPuppet::IsInCombat;ScriptedPuppet",
    (NPCPuppet_IsInCombat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static void ChangeBehaviorState(game.Object obj, game.data.NPCBehaviorState newState) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "NPCPuppet",
    "NPCPuppet::ChangeBehaviorState;GameObjectgamedataNPCBehaviorState",
    (NPCPuppet_ChangeBehaviorState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NPCPuppet_ChangeBehaviorState(
    game.Object? obj,
    game.data.NPCBehaviorState newState
);