class

ScriptedPuppet

65 properties
394 functions
2 derived classes

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

Derived

Properties

Property	Type	Offset
`aiController`	`AIHumanComponent?`	`0xF0`	scripted
`movePolicies`	`move.PoliciesComponent?`	`0x100`	scripted
`aiStateHandlerComponent`	`AIPhaseStateEventHandlerComponent?`	`0x110`	scripted
`hitReactionComponent`	`HitReactionComponent?`	`0x120`	scripted
`signalHandlerComponent`	`AISignalHandlerComponent?`	`0x130`	scripted
`reactionComponent`	`ReactionManagerComponent?`	`0x140`	scripted
`dismembermentComponent`	`game.DismembermentComponent?`	`0x150`	scripted
`hitRepresantation`	`ent.SlotComponent?`	`0x160`	scripted
`interactionComponent`	`game.interactions.Component?`	`0x170`	scripted
`slotComponent`	`ent.SlotComponent?`	`0x180`	scripted
`sensesComponent`	`sense.Component?`	`0x190`	scripted
`visibleObjectComponent`	`sense.VisibleObjectComponent?`	`0x1A0`	scripted
`visibleObjectPositionUpdated`	`bool`	`0x1B0`	scripted
`sensorObjectComponent`	`sense.SensorObjectComponent?`	`0x1B8`	scripted
`targetTrackerComponent`	`AITargetTrackerComponent?`	`0x1C8`	scripted
`targetingComponentsArray`	`game.TargetingComponent?[]`	`0x1D8`	scripted
`statesComponent`	`NPCStatesComponent?`	`0x1E8`	scripted
`fxResourceMapper`	`FxResourceMapperComponent?`	`0x1F8`	scripted
`linkedStatusEffect`	`LinkedStatusEffect`	`0x208`	scripted
`resourceLibraryComponent`	`ResourceLibraryComponent?`	`0x230`	scripted
`crowdMemberComponent`	`CrowdMemberBaseComponent?`	`0x240`	scripted
`inventoryComponent`	`WeakHandle<game.Inventory>`	`0x250`	scripted
`objectSelectionComponent`	`AIObjectSelectionComponent?`	`0x260`	scripted
`transformHistoryComponent`	`ent.TransformHistoryComponent?`	`0x270`	scripted
`animationControllerComponent`	`ent.AnimationControllerComponent?`	`0x280`	scripted
`bumpComponent`	`game.influence.BumpComponent?`	`0x290`	scripted
`isCrowd`	`bool`	`0x2A0`	scripted
`incapacitatedOnAttach`	`bool`	`0x2A1`	scripted
`isIconic`	`bool`	`0x2A2`	scripted
`combatHUDManager`	`CombatHUDManager?`	`0x2A8`	scripted
`exposePosition`	`bool`	`0x2B8`	scripted
`puppetStateBlackboard`	`game.IBlackboard?`	`0x2C0`	scripted
`customBlackboard`	`game.IBlackboard?`	`0x2D0`	scripted
`securityAreaCallbackID`	`uint`	`0x2E0`	scripted
`customAIComponents`	`AICustomComponents?[]`	`0x2E8`	scripted
`listeners`	`PuppetListener?[]`	`0x2F8`	scripted
`securitySupportListener`	`SecuritySupportListener?`	`0x308`	scripted
`shouldBeRevealedStorage`	`RevealRequestsStorage?`	`0x318`	scripted
`inputProcessed`	`bool`	`0x328`	scripted
`shouldSpawnBloodPuddle`	`bool`	`0x329`	scripted
`bloodPuddleSpawned`	`bool`	`0x32A`	scripted
`skipDeathAnimation`	`bool`	`0x32B`	scripted
`hitHistory`	`HitHistory?`	`0x330`	scripted
`currentWorkspotTags`	`CName[]`	`0x340`	scripted
`lootQuality`	`game.data.Quality`	`0x350`	scripted
`hasQuestItems`	`bool`	`0x354`	scripted
`activeQualityRangeInteraction`	`CName`	`0x358`	scripted
`droppedWeapons`	`bool`	`0x360`	scripted
`weakspotComponent`	`game.WeakspotComponent?`	`0x368`	scripted
`breachControllerComponent`	`game.BreachControllerComponent?`	`0x378`	scripted
`highlightData`	`FocusForcedHighlightData?`	`0x388`	scripted
`currentTagsStack`	`uint`	`0x398`	scripted
`killer`	`WeakHandle<ent.Entity>`	`0x3A0`	scripted
`objectActionsCallbackCtrl`	`game.ObjectActionsCallbackController?`	`0x3B0`	scripted
`isActiveCached`	`AIUtilsCachedBoolValue`	`0x3C0`	scripted
`isCyberpsycho`	`bool`	`0x3C3`	scripted
`isCivilian`	`bool`	`0x3C4`	scripted
`isPolice`	`bool`	`0x3C5`	scripted
`isGanger`	`bool`	`0x3C6`	scripted
`currentlyUploadingAction`	`WeakHandle<ScriptableDeviceAction>`	`0x3C8`	scripted
`gameplayRoleComponent`	`WeakHandle<GameplayRoleComponent>`	`0x3D8`	scripted
`activeQuickhackActionHistory`	`ScriptableDeviceAction?[]`	`0x3E8`	scripted
`completedQuickhackHistory`	`ScriptableDeviceAction?[]`	`0x3F8`	scripted
`isFinsherSoundPlayed`	`bool`	`0x408`	scripted
`attemptedShards`	`game.ItemID[]`	`0x410`	scripted

Functions

void DetermineInteractionStateByTask() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "DetermineInteractionStateByTask;",
    (ScriptedPuppet_DetermineInteractionStateByTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_DetermineInteractionStateByTask(
    ScriptedPuppet self
);

void DetermineInteractionStateTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "DetermineInteractionStateTask;ScriptTaskData",
    (ScriptedPuppet_DetermineInteractionStateTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void HandleDeath(WeakHandle<game.Object> instigator) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "HandleDeath;GameObject",
    (ScriptedPuppet_HandleDeath x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void HandleDefeatedByTask() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "HandleDefeatedByTask;",
    (ScriptedPuppet_HandleDefeatedByTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_HandleDefeatedByTask(
    ScriptedPuppet self
);

void HandleDefeatedTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "HandleDefeatedTask;ScriptTaskData",
    (ScriptedPuppet_HandleDefeatedTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void HandleDefeated() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "HandleDefeated;",
    (ScriptedPuppet_HandleDefeated x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_HandleDefeated(
    ScriptedPuppet self
);

void EvaluateLootQualityByTask() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "EvaluateLootQualityByTask;",
    (ScriptedPuppet_EvaluateLootQualityByTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_EvaluateLootQualityByTask(
    ScriptedPuppet self
);

void EvaluateLootQualityTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "EvaluateLootQualityTask;ScriptTaskData",
    (ScriptedPuppet_EvaluateLootQualityTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void ResolveConnectionWithDeviceSystem() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ResolveConnectionWithDeviceSystem;",
    (ScriptedPuppet_ResolveConnectionWithDeviceSystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ResolveConnectionWithDeviceSystem(
    ScriptedPuppet self
);

void ResolveConnectionWithDeviceSystemTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ResolveConnectionWithDeviceSystemTask;ScriptTaskData",
    (ScriptedPuppet_ResolveConnectionWithDeviceSystemTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void EquipSavedLoadout() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "EquipSavedLoadout;",
    (ScriptedPuppet_EquipSavedLoadout x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_EquipSavedLoadout(
    ScriptedPuppet self
);

void EquipSavedLoadoutTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "EquipSavedLoadoutTask;ScriptTaskData",
    (ScriptedPuppet_EquipSavedLoadoutTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

WeakHandle<ent.Entity> GetKiller() RTTI

void SetKiller(WeakHandle<ent.Entity> killer) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "SetKiller;Entity",
    (ScriptedPuppet_SetKiller x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_SetKiller(
    ScriptedPuppet self,
    WeakHandle<ent.Entity> killer
);

bool OnRequestComponents(ent.EntityRequestComponentsInterface ri) overrideRTTI

Generated hook

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

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

bool OnTakeControl(ent.EntityResolveComponentsInterface ri) overrideRTTI

Generated hook

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

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

bool OnGameAttached() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnGameAttached(
    ScriptedPuppet self
);

bool OnDetach() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnDetach(
    ScriptedPuppet self
);

bool OnEvaluateMinigame(EvaluateMinigame evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnEvaluateMinigame",
    (ScriptedPuppet_OnEvaluateMinigame x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnEvaluateMinigame(
    ScriptedPuppet self,
    EvaluateMinigame? evt
);

void ProcessLootMinigame(float baseMoney, float baseUncommonMaterials, float baseRareMaterials, float baseEpicMaterials, float baseLegendaryMaterials, float baseShardDropChance, game.TransactionSystem TS)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ProcessLootMinigame;FloatFloatFloatFloatFloatFloatTransactionSystem",
    (ScriptedPuppet_ProcessLootMinigame x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ProcessLootMinigame(
    ScriptedPuppet self,
    float baseMoney,
    float baseUncommonMaterials,
    float baseRareMaterials,
    float baseEpicMaterials,
    float baseLegendaryMaterials,
    float baseShardDropChance,
    game.TransactionSystem? TS
);

void GenerateMaterialDrops(float baseUncommonMaterials, float baseRareMaterials, float baseEpicMaterials, float baseLegendaryMaterials, game.TransactionSystem TS)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "GenerateMaterialDrops;FloatFloatFloatFloatTransactionSystem",
    (ScriptedPuppet_GenerateMaterialDrops x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GenerateMaterialDrops(
    ScriptedPuppet self,
    float baseUncommonMaterials,
    float baseRareMaterials,
    float baseEpicMaterials,
    float baseLegendaryMaterials,
    game.TransactionSystem? TS
);

game.WeakspotComponent? GetWeakspotComponent() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetWeakspotComponent;",
    (ScriptedPuppet_GetWeakspotComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.WeakspotComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetWeakspotComponent(
    ScriptedPuppet self
);

game.BreachControllerComponent? GetBreachControllerComponent() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetBreachControllerComponent;",
    (ScriptedPuppet_GetBreachControllerComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.BreachControllerComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetBreachControllerComponent(
    ScriptedPuppet self
);

bool IsAimAssistEnabled() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsAimAssistEnabled;",
    (ScriptedPuppet_IsAimAssistEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsAimAssistEnabled(
    ScriptedPuppet self
);

void Update(float dt) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "Update;Float",
    (ScriptedPuppet_Update x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_Update(
    ScriptedPuppet self,
    float dt
);

void UpdateQuickHackableState(bool isQuickHackable) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "UpdateQuickHackableState;Bool",
    (ScriptedPuppet_UpdateQuickHackableState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_UpdateQuickHackableState(
    ScriptedPuppet self,
    bool isQuickHackable
);

CooldownStorage? GetCooldownStorage() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetCooldownStorage;",
    (ScriptedPuppet_GetCooldownStorage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CooldownStorage>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetCooldownStorage(
    ScriptedPuppet self
);

bool GetItemMinigameAttempted(game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetItemMinigameAttempted;ItemID",
    (ScriptedPuppet_GetItemMinigameAttempted x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetItemMinigameAttempted(
    ScriptedPuppet self,
    game.ItemID itemID
);

void SetItemMinigameAttempted(game.ItemID itemID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "SetItemMinigameAttempted;ItemID",
    (ScriptedPuppet_SetItemMinigameAttempted x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_SetItemMinigameAttempted(
    ScriptedPuppet self,
    game.ItemID itemID
);

LinkedStatusEffect GetLinkedStatusEffect() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetLinkedStatusEffect;",
    (ScriptedPuppet_GetLinkedStatusEffect x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.LinkedStatusEffect>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetLinkedStatusEffect(
    ScriptedPuppet self
);

void AddLinkedStatusEffect(ent.EntityID netrunner, ent.EntityID target, WeakHandle<game.data.ObjectActionEffect_Record>[]? actionEffects)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "AddLinkedStatusEffect;EntityIDEntityIDarray<ObjectActionEffect_Record>",
    (ScriptedPuppet_AddLinkedStatusEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_AddLinkedStatusEffect(
    ScriptedPuppet self,
    ent.EntityID netrunner,
    ent.EntityID target,
    WeakHandle<game.data.ObjectActionEffect_Record>[]? actionEffects
);

bool RemoveLinkedStatusEffects(bool? ssAction) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_RemoveLinkedStatusEffects(
    ScriptedPuppet self,
    bool? ssAction
);

void ClearLinkedStatusEffect() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ClearLinkedStatusEffect;",
    (ScriptedPuppet_ClearLinkedStatusEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ClearLinkedStatusEffect(
    ScriptedPuppet self
);

bool RemoveLinkedStatusEffectsFromTarget(ent.EntityID sourceID, bool? ssAction) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "RemoveLinkedStatusEffectsFromTarget;EntityIDBool",
    (ScriptedPuppet_RemoveLinkedStatusEffectsFromTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_RemoveLinkedStatusEffectsFromTarget(
    ScriptedPuppet self,
    ent.EntityID sourceID,
    bool? ssAction
);

void RemoveLink() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_RemoveLink(
    ScriptedPuppet self
);

bool OnExitShapeEvent(sense.OnExitShapeEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnExitShapeEvent",
    (ScriptedPuppet_OnExitShapeEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnExitShapeEvent(
    ScriptedPuppet self,
    sense.OnExitShapeEvent? evt
);

void ToggleInteractionLayers() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ToggleInteractionLayers;",
    (ScriptedPuppet_ToggleInteractionLayers x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ToggleInteractionLayers(
    ScriptedPuppet self
);

void CreateListeners() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_CreateListeners(
    ScriptedPuppet self
);

void RemoveListeners() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_RemoveListeners(
    ScriptedPuppet self
);

ConnectedClassTypes GetMasterConnectedClassTypes() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetMasterConnectedClassTypes;",
    (ScriptedPuppet_GetMasterConnectedClassTypes x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ConnectedClassTypes>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetMasterConnectedClassTypes(
    ScriptedPuppet self
);

bool OnCreateCustomBlackboard(CreateCustomBlackboardEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnCreateCustomBlackboard",
    (ScriptedPuppet_OnCreateCustomBlackboard x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnCreateCustomBlackboard(
    ScriptedPuppet self,
    CreateCustomBlackboardEvent? evt
);

game.IBlackboard? GetCustomBlackboard() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetCustomBlackboard;",
    (ScriptedPuppet_GetCustomBlackboard x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IBlackboard>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetCustomBlackboard(
    ScriptedPuppet self
);

bool OnAddOrRemoveListener(AddOrRemoveListenerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnAddOrRemoveListener",
    (ScriptedPuppet_OnAddOrRemoveListener x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnAddOrRemoveListener(
    ScriptedPuppet self,
    AddOrRemoveListenerEvent? evt
);

void NotifyHitReactionTypeChanged(int hitType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "NotifyHitReactionTypeChanged;Int32",
    (ScriptedPuppet_NotifyHitReactionTypeChanged x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_NotifyHitReactionTypeChanged(
    ScriptedPuppet self,
    int hitType
);

void NotifyHitReactionSourceChanged(int hitSource) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "NotifyHitReactionSourceChanged;Int32",
    (ScriptedPuppet_NotifyHitReactionSourceChanged x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_NotifyHitReactionSourceChanged(
    ScriptedPuppet self,
    int hitSource
);

AIHumanComponent? GetAIControllerComponent() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetAIControllerComponent;",
    (ScriptedPuppet_GetAIControllerComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.AIHumanComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetAIControllerComponent(
    ScriptedPuppet self
);

move.PoliciesComponent? GetMovePolicesComponent() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetMovePolicesComponent;",
    (ScriptedPuppet_GetMovePolicesComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.move.PoliciesComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetMovePolicesComponent(
    ScriptedPuppet self
);

AISignalHandlerComponent? GetSignalHandlerComponent() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetSignalHandlerComponent;",
    (ScriptedPuppet_GetSignalHandlerComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.AISignalHandlerComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetSignalHandlerComponent(
    ScriptedPuppet self
);

HitReactionComponent? GetHitReactionComponent() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetHitReactionComponent;",
    (ScriptedPuppet_GetHitReactionComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.HitReactionComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetHitReactionComponent(
    ScriptedPuppet self
);

ReactionManagerComponent? GetStimReactionComponent() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetStimReactionComponent(
    ScriptedPuppet self
);

game.DismembermentComponent? GetDismembermentComponent() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetDismembermentComponent;",
    (ScriptedPuppet_GetDismembermentComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.DismembermentComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetDismembermentComponent(
    ScriptedPuppet self
);

CrowdMemberBaseComponent? GetCrowdMemberComponent() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetCrowdMemberComponent;",
    (ScriptedPuppet_GetCrowdMemberComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CrowdMemberBaseComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetCrowdMemberComponent(
    ScriptedPuppet self
);

AITargetTrackerComponent? GetTargetTrackerComponent() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetTargetTrackerComponent(
    ScriptedPuppet self
);

TargetTrackingExtension? GetTargetTrackingExension() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetTargetTrackingExension;",
    (ScriptedPuppet_GetTargetTrackingExension x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TargetTrackingExtension>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetTargetTrackingExension(
    ScriptedPuppet self
);

AIObjectSelectionComponent? GetObjectSelectionComponent() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetObjectSelectionComponent;",
    (ScriptedPuppet_GetObjectSelectionComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.AIObjectSelectionComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetObjectSelectionComponent(
    ScriptedPuppet self
);

game.IBlackboard? GetPuppetStateBlackboard() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetPuppetStateBlackboard;",
    (ScriptedPuppet_GetPuppetStateBlackboard x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IBlackboard>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetPuppetStateBlackboard(
    ScriptedPuppet self
);

ent.SlotComponent? GetHitRepresantationSlotComponent() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetHitRepresantationSlotComponent;",
    (ScriptedPuppet_GetHitRepresantationSlotComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.SlotComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetHitRepresantationSlotComponent(
    ScriptedPuppet self
);

ent.SlotComponent? GetSlotComponent() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetSlotComponent;",
    (ScriptedPuppet_GetSlotComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.SlotComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetSlotComponent(
    ScriptedPuppet self
);

CombatHUDManager? GetCombatHUDManagerComponent() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetCombatHUDManagerComponent;",
    (ScriptedPuppet_GetCombatHUDManagerComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CombatHUDManager>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetCombatHUDManagerComponent(
    ScriptedPuppet self
);

sense.Component? GetSensesComponent() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetSensesComponent(
    ScriptedPuppet self
);

sense.VisibleObjectComponent? GetVisibleObjectComponent() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetVisibleObjectComponent(
    ScriptedPuppet self
);

sense.SensorObjectComponent? GetSensorObjectComponent() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetSensorObjectComponent;",
    (ScriptedPuppet_GetSensorObjectComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.sense.SensorObjectComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetSensorObjectComponent(
    ScriptedPuppet self
);

game.AttitudeAgent? GetAttitudeAgent() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetAttitudeAgent(
    ScriptedPuppet self
);

NPCStatesComponent? GetStatesComponent() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetStatesComponent;",
    (ScriptedPuppet_GetStatesComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.NPCStatesComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetStatesComponent(
    ScriptedPuppet self
);

game.influence.BumpComponent? GetBumpComponent() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetBumpComponent;",
    (ScriptedPuppet_GetBumpComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.influence.BumpComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetBumpComponent(
    ScriptedPuppet self
);

game.BoolSignalTable? GetSignalTable() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetSignalTable;",
    (ScriptedPuppet_GetSignalTable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.BoolSignalTable>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetSignalTable(
    ScriptedPuppet self
);

ent.TransformHistoryComponent? GetTransformHistoryComponent() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetTransformHistoryComponent;",
    (ScriptedPuppet_GetTransformHistoryComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.TransformHistoryComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetTransformHistoryComponent(
    ScriptedPuppet self
);

ent.AnimationControllerComponent? GetAnimationControllerComponent() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetAnimationControllerComponent;",
    (ScriptedPuppet_GetAnimationControllerComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.AnimationControllerComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetAnimationControllerComponent(
    ScriptedPuppet self
);

bool GetAreIncomingSecuritySystemEventsSuppressed() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetAreIncomingSecuritySystemEventsSuppressed;",
    (ScriptedPuppet_GetAreIncomingSecuritySystemEventsSuppressed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetAreIncomingSecuritySystemEventsSuppressed(
    ScriptedPuppet self
);

game.data.Character_Record? GetRecord() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetRecord;",
    (ScriptedPuppet_GetRecord x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Character_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetRecord(
    ScriptedPuppet self
);

game.data.NPCType GetNPCType() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetNPCType;",
    (ScriptedPuppet_GetNPCType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.NPCType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetNPCType(
    ScriptedPuppet self
);

bool IsAndroid() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsAndroid;",
    (ScriptedPuppet_IsAndroid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsAndroid(
    ScriptedPuppet self
);

bool IsMech() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsMech;",
    (ScriptedPuppet_IsMech x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsMech(
    ScriptedPuppet self
);

bool IsHuman() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsHuman;",
    (ScriptedPuppet_IsHuman x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsHuman(
    ScriptedPuppet self
);

bool IsCerberus() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsCerberus;",
    (ScriptedPuppet_IsCerberus x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsCerberus(
    ScriptedPuppet self
);

bool IsHumanoid() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsHumanoid;",
    (ScriptedPuppet_IsHumanoid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsHumanoid(
    ScriptedPuppet self
);

bool IsNetrunnerPuppet() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsNetrunnerPuppet;",
    (ScriptedPuppet_IsNetrunnerPuppet x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsNetrunnerPuppet(
    ScriptedPuppet self
);

bool IsMechanical() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsMechanical;",
    (ScriptedPuppet_IsMechanical x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsMechanical(
    ScriptedPuppet self
);

bool IsResistantToTakedown() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsResistantToTakedown;",
    (ScriptedPuppet_IsResistantToTakedown x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsResistantToTakedown(
    ScriptedPuppet self
);

bool IsFinisherSoundPlayed() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsFinisherSoundPlayed;",
    (ScriptedPuppet_IsFinisherSoundPlayed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsFinisherSoundPlayed(
    ScriptedPuppet self
);

void SetFinisherSoundPlayed(bool value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "SetFinisherSoundPlayed;Bool",
    (ScriptedPuppet_SetFinisherSoundPlayed x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

ScriptedPuppetPS? GetPS() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetPS(
    ScriptedPuppet self
);

ScriptedPuppetPS? GetPuppetPS() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetPuppetPS;",
    (ScriptedPuppet_GetPuppetPS x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ScriptedPuppetPS>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetPuppetPS(
    ScriptedPuppet self
);

game.data.NPCHighLevelState GetHighLevelStateFromBlackboard() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetHighLevelStateFromBlackboard;",
    (ScriptedPuppet_GetHighLevelStateFromBlackboard x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.NPCHighLevelState>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetHighLevelStateFromBlackboard(
    ScriptedPuppet self
);

game.data.NPCUpperBodyState GetUpperBodyStateFromBlackboard() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetUpperBodyStateFromBlackboard;",
    (ScriptedPuppet_GetUpperBodyStateFromBlackboard x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.NPCUpperBodyState>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetUpperBodyStateFromBlackboard(
    ScriptedPuppet self
);

game.data.DefenseMode GetDefenseModeStateFromBlackboard() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetDefenseModeStateFromBlackboard;",
    (ScriptedPuppet_GetDefenseModeStateFromBlackboard x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.DefenseMode>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetDefenseModeStateFromBlackboard(
    ScriptedPuppet self
);

game.data.NPCStanceState GetStanceStateFromBlackboard() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetStanceStateFromBlackboard;",
    (ScriptedPuppet_GetStanceStateFromBlackboard x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.NPCStanceState>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetStanceStateFromBlackboard(
    ScriptedPuppet self
);

EHitReactionMode GetHitReactionModeFromBlackboard() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetHitReactionModeFromBlackboard;",
    (ScriptedPuppet_GetHitReactionModeFromBlackboard x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EHitReactionMode>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetHitReactionModeFromBlackboard(
    ScriptedPuppet self
);

CName[] GetCurrentWorkspotTags() RTTI

bool HasWorkspotTag(CName tag) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "HasWorkspotTag;CName",
    (ScriptedPuppet_HasWorkspotTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_HasWorkspotTag(
    ScriptedPuppet self,
    CName tag
);

bool IsPuppet() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsPuppet;",
    (ScriptedPuppet_IsPuppet x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsPuppet(
    ScriptedPuppet self
);

bool IsPuppetInCombat() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsPuppetInCombat(
    ScriptedPuppet self
);

bool IsOfficer() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsOfficer;",
    (ScriptedPuppet_IsOfficer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsOfficer(
    ScriptedPuppet self
);

void RegisterSubCharacter() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "RegisterSubCharacter;",
    (ScriptedPuppet_RegisterSubCharacter x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_RegisterSubCharacter(
    ScriptedPuppet self
);

void UnregisterSubCharacter() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "UnregisterSubCharacter;",
    (ScriptedPuppet_UnregisterSubCharacter x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_UnregisterSubCharacter(
    ScriptedPuppet self
);

bool IsBoss() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsBoss;",
    (ScriptedPuppet_IsBoss x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsBoss(
    ScriptedPuppet self
);

bool IsMaxTac() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsMaxTac;",
    (ScriptedPuppet_IsMaxTac x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsMaxTac(
    ScriptedPuppet self
);

bool AllowFinisherThreshold() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "AllowFinisherThreshold;",
    (ScriptedPuppet_AllowFinisherThreshold x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_AllowFinisherThreshold(
    ScriptedPuppet self
);

bool IsElite() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsElite;",
    (ScriptedPuppet_IsElite x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsElite(
    ScriptedPuppet self
);

bool IsMassive() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsMassive;",
    (ScriptedPuppet_IsMassive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsMassive(
    ScriptedPuppet self
);

bool IsDrone() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsDrone;",
    (ScriptedPuppet_IsDrone x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsDrone(
    ScriptedPuppet self
);

bool IsVendor() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsVendor;",
    (ScriptedPuppet_IsVendor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsVendor(
    ScriptedPuppet self
);

game.data.VendorType GetVendorType() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetVendorType;",
    (ScriptedPuppet_GetVendorType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.VendorType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetVendorType(
    ScriptedPuppet self
);

void RefreshCachedReactionPresetData() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "RefreshCachedReactionPresetData;",
    (ScriptedPuppet_RefreshCachedReactionPresetData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_RefreshCachedReactionPresetData(
    ScriptedPuppet self
);

bool IsCivilian() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsCivilian;",
    (ScriptedPuppet_IsCivilian x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsCivilian(
    ScriptedPuppet self
);

void TryRegisterToPrevention() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "TryRegisterToPrevention;",
    (ScriptedPuppet_TryRegisterToPrevention x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_TryRegisterToPrevention(
    ScriptedPuppet self
);

void RefreshCachedDataCharacterTags() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "RefreshCachedDataCharacterTags;",
    (ScriptedPuppet_RefreshCachedDataCharacterTags x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_RefreshCachedDataCharacterTags(
    ScriptedPuppet self
);

void StopPoliceBehaviour() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "StopPoliceBehaviour;",
    (ScriptedPuppet_StopPoliceBehaviour x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_StopPoliceBehaviour(
    ScriptedPuppet self
);

bool IsCharacterCyberpsycho() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsCharacterCyberpsycho;",
    (ScriptedPuppet_IsCharacterCyberpsycho x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsCharacterCyberpsycho(
    ScriptedPuppet self
);

bool IsCharacterCivilian() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsCharacterCivilian;",
    (ScriptedPuppet_IsCharacterCivilian x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsCharacterCivilian(
    ScriptedPuppet self
);

bool IsCharacterPolice() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsCharacterPolice;",
    (ScriptedPuppet_IsCharacterPolice x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsCharacterPolice(
    ScriptedPuppet self
);

bool IsCharacterGanger() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsCharacterGanger;",
    (ScriptedPuppet_IsCharacterGanger x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsCharacterGanger(
    ScriptedPuppet self
);

bool IsCharacterChildren() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsCharacterChildren;",
    (ScriptedPuppet_IsCharacterChildren x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsCharacterChildren(
    ScriptedPuppet self
);

bool GetCrowd() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetCrowd;",
    (ScriptedPuppet_GetCrowd x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetCrowd(
    ScriptedPuppet self
);

bool IsCrowd() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsCrowd;",
    (ScriptedPuppet_IsCrowd x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsCrowd(
    ScriptedPuppet self
);

bool GetWasAggressiveCrowd() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetWasAggressiveCrowd(
    ScriptedPuppet self
);

void SetWasIncapacitatedOnAttach(bool value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "SetWasIncapacitatedOnAttach;Bool",
    (ScriptedPuppet_SetWasIncapacitatedOnAttach x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool WasIncapacitatedOnAttach() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "WasIncapacitatedOnAttach;",
    (ScriptedPuppet_WasIncapacitatedOnAttach x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_WasIncapacitatedOnAttach(
    ScriptedPuppet self
);

bool AwardsExperience() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "AwardsExperience;",
    (ScriptedPuppet_AwardsExperience x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_AwardsExperience(
    ScriptedPuppet self
);

bool IsTurnedOffNoStatusEffect() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsTurnedOffNoStatusEffect;",
    (ScriptedPuppet_IsTurnedOffNoStatusEffect x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsTurnedOffNoStatusEffect(
    ScriptedPuppet self
);

bool IsActiveInternal() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsActiveInternal;",
    (ScriptedPuppet_IsActiveInternal x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsActiveInternal(
    ScriptedPuppet self
);

bool IsActive() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsActive;",
    (ScriptedPuppet_IsActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsActive(
    ScriptedPuppet self
);

bool IsPrevention() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsPrevention(
    ScriptedPuppet self
);

bool IsDead() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsDead(
    ScriptedPuppet self
);

bool IsDeadNoStatPool() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsDeadNoStatPool;",
    (ScriptedPuppet_IsDeadNoStatPool x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsDeadNoStatPool(
    ScriptedPuppet self
);

TDBID GetReactionPresetID() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetReactionPresetID;",
    (ScriptedPuppet_GetReactionPresetID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetReactionPresetID(
    ScriptedPuppet self
);

void SetReactionPresetID(TDBID presetID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "SetReactionPresetID;TweakDBID",
    (ScriptedPuppet_SetReactionPresetID x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_SetReactionPresetID(
    ScriptedPuppet self,
    TDBID presetID
);

bool IsEnemy() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsEnemy;",
    (ScriptedPuppet_IsEnemy x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsEnemy(
    ScriptedPuppet self
);

bool IsAggressive() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsAggressive;",
    (ScriptedPuppet_IsAggressive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsAggressive(
    ScriptedPuppet self
);

bool IsOnAutonomousAI() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsOnAutonomousAI;",
    (ScriptedPuppet_IsOnAutonomousAI x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsOnAutonomousAI(
    ScriptedPuppet self
);

bool CanBeTagged() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "CanBeTagged;",
    (ScriptedPuppet_CanBeTagged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_CanBeTagged(
    ScriptedPuppet self
);

bool IsPlayerCompanion() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsPlayerCompanion(
    ScriptedPuppet self
);

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

Generated hook

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

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

void SoftKill(WeakHandle<game.Object>? instigator, bool? skipNPCDeathAnim, bool? disableNPCRagdoll) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "SoftKill;GameObjectBoolBool",
    (ScriptedPuppet_SoftKill x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool HasHeadUnderwater() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_HasHeadUnderwater(
    ScriptedPuppet self
);

bool IsUnderwater(float? howDeep) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsUnderwater;Float",
    (ScriptedPuppet_IsUnderwater x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsUnderwater(
    ScriptedPuppet self,
    float? howDeep
);

bool OnReevaluateOxygenEvent(ReevaluateOxygenEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnReevaluateOxygenEvent",
    (ScriptedPuppet_OnReevaluateOxygenEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnReevaluateOxygenEvent(
    ScriptedPuppet self,
    ReevaluateOxygenEvent? evt
);

void PuppetSubmergedRequestRemovingStatusEffects(WeakHandle<game.Object> obj) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "PuppetSubmergedRequestRemovingStatusEffects;GameObject",
    (ScriptedPuppet_PuppetSubmergedRequestRemovingStatusEffects x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_PuppetSubmergedRequestRemovingStatusEffects(
    ScriptedPuppet self,
    WeakHandle<game.Object> obj
);

void StartOxygenDecay() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "StartOxygenDecay;",
    (ScriptedPuppet_StartOxygenDecay x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_StartOxygenDecay(
    ScriptedPuppet self
);

void StopOxygenDecay() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "StopOxygenDecay;",
    (ScriptedPuppet_StopOxygenDecay x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_StopOxygenDecay(
    ScriptedPuppet self
);

bool OnRequestDismemberment(RequestDismembermentEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnRequestDismemberment",
    (ScriptedPuppet_OnRequestDismemberment x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnRequestDismemberment(
    ScriptedPuppet self,
    RequestDismembermentEvent? evt
);

bool OnResetSignalAIEventReceived(ResetSignal evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnResetSignalAIEventReceived",
    (ScriptedPuppet_OnResetSignalAIEventReceived x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnResetSignalAIEventReceived(
    ScriptedPuppet self,
    ResetSignal? evt
);

bool OnStatusEffectApplied(game.events.ApplyStatusEffectEvent evt) overrideRTTI

Generated hook

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

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

void EvaluateQuickhacksCount() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "EvaluateQuickhacksCount;",
    (ScriptedPuppet_EvaluateQuickhacksCount x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_EvaluateQuickhacksCount(
    ScriptedPuppet self
);

void SendAIDeathSignal() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "SendAIDeathSignal;",
    (ScriptedPuppet_SendAIDeathSignal x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_SendAIDeathSignal(
    ScriptedPuppet self
);

bool OnStatusEffectRemoved(game.events.RemoveStatusEffect evt) overrideRTTI

Generated hook

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

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

bool OnSetLootInteractionAccessEvent(game.SetLootInteractionAccessibilityEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnSetLootInteractionAccessEvent",
    (ScriptedPuppet_OnSetLootInteractionAccessEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnSetLootInteractionAccessEvent(
    ScriptedPuppet self,
    game.SetLootInteractionAccessibilityEvent? evt
);

bool OnDefeated(game.events.DefeatedEvent evt) RTTI

Generated hook

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

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

bool OnDeath(game.events.DeathEvent evt) RTTI

Generated hook

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

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

void OnDied() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "OnDied;",
    (ScriptedPuppet_OnDied x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnDied(
    ScriptedPuppet self
);

void ProcessQuickHackQueueOnDefeat() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ProcessQuickHackQueueOnDefeat;",
    (ScriptedPuppet_ProcessQuickHackQueueOnDefeat x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ProcessQuickHackQueueOnDefeat(
    ScriptedPuppet self
);

void SquadUpdate(bool leaveSquad, AISquadType squadType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "SquadUpdate;BoolAISquadType",
    (ScriptedPuppet_SquadUpdate x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_SquadUpdate(
    ScriptedPuppet self,
    bool leaveSquad,
    AISquadType squadType
);

void OnIncapacitated() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnIncapacitated(
    ScriptedPuppet self
);

bool OnResurrect(game.events.ResurrectEvent evt) RTTI

Generated hook

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

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

void OnResurrected() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnResurrected(
    ScriptedPuppet self
);

void RewardKiller(WeakHandle<game.Object> killer, game.KillType killType, bool isAnyDamageNonlethal) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "RewardKiller;GameObjectgameKillTypeBool",
    (ScriptedPuppet_RewardKiller x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_RewardKiller(
    ScriptedPuppet self,
    WeakHandle<game.Object> killer,
    game.KillType killType,
    bool isAnyDamageNonlethal
);

bool OnDamageReceived(game.events.DamageReceivedEvent evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnDamageReceived",
    (ScriptedPuppet_OnDamageReceived x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnDamageReceived(
    ScriptedPuppet self,
    game.events.DamageReceivedEvent? evt
);

void LogDamageReceived(game.events.DamageReceivedEvent evt, game.Object instigator, game.TelemetryDamageSituation dmgSituation)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "LogDamageReceived;gameDamageReceivedEventGameObjectgameTelemetryDamageSituation",
    (ScriptedPuppet_LogDamageReceived x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_LogDamageReceived(
    ScriptedPuppet self,
    game.events.DamageReceivedEvent? evt,
    game.Object? instigator,
    game.TelemetryDamageSituation dmgSituation
);

bool OnDamageDealt(game.events.TargetDamageEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnDamageDealt",
    (ScriptedPuppet_OnDamageDealt x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnDamageDealt(
    ScriptedPuppet self,
    game.events.TargetDamageEvent? evt
);

bool OnKillRewardEvent(game.events.KillRewardEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnKillRewardEvent",
    (ScriptedPuppet_OnKillRewardEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnKillRewardEvent(
    ScriptedPuppet self,
    game.events.KillRewardEvent? evt
);

void LogEnemyDown(game.events.KillRewardEvent evt, game.TelemetryDamageSituation dmgSituation) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "LogEnemyDown;KillRewardEventgameTelemetryDamageSituation",
    (ScriptedPuppet_LogEnemyDown x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_LogEnemyDown(
    ScriptedPuppet self,
    game.events.KillRewardEvent? evt,
    game.TelemetryDamageSituation dmgSituation
);

bool HasCalculatedEquipment(EquipmentPriority equipmentPriority, game.data.Character_Record characterRecord) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "HasCalculatedEquipment;EquipmentPriorityCharacter_Record",
    (ScriptedPuppet_HasCalculatedEquipment x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_HasCalculatedEquipment(
    ScriptedPuppet self,
    EquipmentPriority equipmentPriority,
    game.data.Character_Record? characterRecord
);

bool HasEquipment(EquipmentPriority equipmentPriority) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "HasEquipment;EquipmentPriority",
    (ScriptedPuppet_HasEquipment x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_HasEquipment(
    ScriptedPuppet self,
    EquipmentPriority equipmentPriority
);

void GiveEquipment(EquipmentPriority equipmentPriority, game.data.Character_Record characterRecord, int powerLevel) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "GiveEquipment;EquipmentPriorityCharacter_RecordInt32",
    (ScriptedPuppet_GiveEquipment x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GiveEquipment(
    ScriptedPuppet self,
    EquipmentPriority equipmentPriority,
    game.data.Character_Record? characterRecord,
    int powerLevel
);

void AddRecordEquipment(EquipmentPriority equipmentPriority, int? powerLevel) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "AddRecordEquipment;EquipmentPriorityInt32",
    (ScriptedPuppet_AddRecordEquipment x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_AddRecordEquipment(
    ScriptedPuppet self,
    EquipmentPriority equipmentPriority,
    int? powerLevel
);

bool DropHeldItems() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "DropHeldItems;",
    (ScriptedPuppet_DropHeldItems x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_DropHeldItems(
    ScriptedPuppet self
);

bool OnAttitudeChanged(game.events.AttitudeChangedEvent evt) overrideRTTI

Generated hook

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

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

void RevokeAllTickets() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "RevokeAllTickets;",
    (ScriptedPuppet_RevokeAllTickets x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_RevokeAllTickets(
    ScriptedPuppet self
);

void RevokeAllTicketsForPreventionSquad() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "RevokeAllTicketsForPreventionSquad;",
    (ScriptedPuppet_RevokeAllTicketsForPreventionSquad x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_RevokeAllTicketsForPreventionSquad(
    ScriptedPuppet self
);

bool OnHackTargetEvent(HackTargetEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnHackTargetEvent",
    (ScriptedPuppet_OnHackTargetEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnHackTargetEvent(
    ScriptedPuppet self,
    HackTargetEvent? evt
);

void ProcessEnemyNetrunnerTutorialFact() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ProcessEnemyNetrunnerTutorialFact;",
    (ScriptedPuppet_ProcessEnemyNetrunnerTutorialFact x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ProcessEnemyNetrunnerTutorialFact(
    ScriptedPuppet self
);

bool OnRemoveLinkEvent(RemoveLinkEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnRemoveLinkEvent",
    (ScriptedPuppet_OnRemoveLinkEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnRemoveLinkEvent(
    ScriptedPuppet self,
    RemoveLinkEvent? evt
);

bool OnRemoveLinkedStatusEffectsEvent(RemoveLinkedStatusEffectsEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnRemoveLinkedStatusEffectsEvent",
    (ScriptedPuppet_OnRemoveLinkedStatusEffectsEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnRemoveLinkedStatusEffectsEvent(
    ScriptedPuppet self,
    RemoveLinkedStatusEffectsEvent? evt
);

bool OnNetworkLinkQuickhackEvent(NetworkLinkQuickhackEvent evt) RTTI

Generated hook

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

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

void EnableLootInteractionWithDelay(game.Puppet puppet) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "EnableLootInteractionWithDelay;gamePuppet",
    (ScriptedPuppet_EnableLootInteractionWithDelay x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_EnableLootInteractionWithDelay(
    ScriptedPuppet self,
    game.Puppet? puppet
);

bool OnLootPickupDelayEvent(LootPickupDelayEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnLootPickupDelayEvent",
    (ScriptedPuppet_OnLootPickupDelayEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnLootPickupDelayEvent(
    ScriptedPuppet self,
    LootPickupDelayEvent? evt
);

bool OnInteractionActivated(game.interactions.InteractionActivationEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnInteractionActivated",
    (ScriptedPuppet_OnInteractionActivated x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnInteractionActivated(
    ScriptedPuppet self,
    game.interactions.InteractionActivationEvent? evt
);

bool OnInteractionUsed(game.interactions.ChoiceEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnInteractionUsed",
    (ScriptedPuppet_OnInteractionUsed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnInteractionUsed(
    ScriptedPuppet self,
    game.interactions.ChoiceEvent? evt
);

void ProcessNewPerkFinisherLayer(game.interactions.ChoiceEvent evt, PlayerPuppet playerPuppet, NPCPuppet npcPuppet) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ProcessNewPerkFinisherLayer;InteractionChoiceEventPlayerPuppetNPCPuppet",
    (ScriptedPuppet_ProcessNewPerkFinisherLayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ProcessNewPerkFinisherLayer(
    ScriptedPuppet self,
    game.interactions.ChoiceEvent? evt,
    PlayerPuppet? playerPuppet,
    NPCPuppet? npcPuppet
);

void TriggerNewPerkFinisher(game.interactions.ChoiceEvent evt, PlayerPuppet playerPuppet) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "TriggerNewPerkFinisher;InteractionChoiceEventPlayerPuppet",
    (ScriptedPuppet_TriggerNewPerkFinisher x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_TriggerNewPerkFinisher(
    ScriptedPuppet self,
    game.interactions.ChoiceEvent? evt,
    PlayerPuppet? playerPuppet
);

void TriggerNewPerkFinisherBluntHold(PlayerPuppet playerPuppet, NPCPuppet npcPuppet) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "TriggerNewPerkFinisherBluntHold;PlayerPuppetNPCPuppet",
    (ScriptedPuppet_TriggerNewPerkFinisherBluntHold x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_TriggerNewPerkFinisherBluntHold(
    ScriptedPuppet self,
    PlayerPuppet? playerPuppet,
    NPCPuppet? npcPuppet
);

void ExecuteAction(game.interactions.Choice choice) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ExecuteAction;script_ref<InteractionChoice>",
    (ScriptedPuppet_ExecuteAction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ExecuteAction(
    ScriptedPuppet self,
    game.interactions.Choice choice
);

bool OnExecutePuppetAction(ExecutePuppetActionEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnExecutePuppetAction",
    (ScriptedPuppet_OnExecutePuppetAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnExecutePuppetAction(
    ScriptedPuppet self,
    ExecutePuppetActionEvent? evt
);

bool OnCommunicationEvent(CommunicationEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnCommunicationEvent",
    (ScriptedPuppet_OnCommunicationEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnCommunicationEvent(
    ScriptedPuppet self,
    CommunicationEvent? evt
);

void ShowQuickHackDuration(ScriptableDeviceAction action) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ShowQuickHackDuration;ScriptableDeviceAction",
    (ScriptedPuppet_ShowQuickHackDuration x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ShowQuickHackDuration(
    ScriptedPuppet self,
    ScriptableDeviceAction? action
);

void ExecuteAction(ScriptableDeviceAction action) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ExecuteAction;ScriptableDeviceAction",
    (ScriptedPuppet_ExecuteAction2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ExecuteAction2(
    ScriptedPuppet self,
    ScriptableDeviceAction? action
);

bool OnInteraction(game.interactions.ChoiceEvent choiceEvent) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnInteraction",
    (ScriptedPuppet_OnInteraction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnInteraction(
    ScriptedPuppet self,
    game.interactions.ChoiceEvent? choiceEvent
);

void LootAllItems(game.interactions.ChoiceEvent choiceEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "LootAllItems;InteractionChoiceEvent",
    (ScriptedPuppet_LootAllItems x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_LootAllItems(
    ScriptedPuppet self,
    game.interactions.ChoiceEvent? choiceEvent
);

bool OnWorkspotStartedEvent(work.WorkspotStartedEvent evt) RTTI

Generated hook

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

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

bool OnWorkspotFinishedEvent(work.WorkspotFinishedEvent evt) RTTI

Generated hook

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

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

void ProcessSyncedAnimationPuppetActions(game.interactions.ChoiceEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ProcessSyncedAnimationPuppetActions;InteractionChoiceEvent",
    (ScriptedPuppet_ProcessSyncedAnimationPuppetActions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ProcessSyncedAnimationPuppetActions(
    ScriptedPuppet self,
    game.interactions.ChoiceEvent? evt
);

void PushFinisherActionEventToPSM(game.interactions.ChoiceEvent evt, bool isFastFinisher) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "PushFinisherActionEventToPSM;InteractionChoiceEventBool",
    (ScriptedPuppet_PushFinisherActionEventToPSM x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_PushFinisherActionEventToPSM(
    ScriptedPuppet self,
    game.interactions.ChoiceEvent? evt,
    bool isFastFinisher
);

void PushTakedownActionEventToPSM(game.interactions.ChoiceEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "PushTakedownActionEventToPSM;InteractionChoiceEvent",
    (ScriptedPuppet_PushTakedownActionEventToPSM x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_PushTakedownActionEventToPSM(
    ScriptedPuppet self,
    game.interactions.ChoiceEvent? evt
);

void CreateTakedownEventOnLayerActivation(game.interactions.InteractionActivationEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "CreateTakedownEventOnLayerActivation;InteractionActivationEvent",
    (ScriptedPuppet_CreateTakedownEventOnLayerActivation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_CreateTakedownEventOnLayerActivation(
    ScriptedPuppet self,
    game.interactions.InteractionActivationEvent? evt
);

void OrderChoice(game.interactions.ChoiceEvent choiceEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "OrderChoice;InteractionChoiceEvent",
    (ScriptedPuppet_OrderChoice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OrderChoice(
    ScriptedPuppet self,
    game.interactions.ChoiceEvent? choiceEvent
);

bool OnDelayedTakedownGameEffectEvent(DelayedGameEffectEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnDelayedTakedownGameEffectEvent",
    (ScriptedPuppet_OnDelayedTakedownGameEffectEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnDelayedTakedownGameEffectEvent(
    ScriptedPuppet self,
    DelayedGameEffectEvent? evt
);

void SendInteractionChoiceToPSM(game.interactions.ChoiceEvent choiceEvent, CName id, bool isChoiceActive) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "SendInteractionChoiceToPSM;InteractionChoiceEventCNameBool",
    (ScriptedPuppet_SendInteractionChoiceToPSM x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_SendInteractionChoiceToPSM(
    ScriptedPuppet self,
    game.interactions.ChoiceEvent? choiceEvent,
    CName id,
    bool isChoiceActive
);

void EnableSensesComponent(bool b) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "EnableSensesComponent;Bool",
    (ScriptedPuppet_EnableSensesComponent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void EnableInteraction(CName layer, bool b) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "EnableInteraction;CNameBool",
    (ScriptedPuppet_EnableInteraction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_EnableInteraction(
    ScriptedPuppet self,
    CName layer,
    bool b
);

bool IsQuest() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsQuest;",
    (ScriptedPuppet_IsQuest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsQuest(
    ScriptedPuppet self
);

bool OnRegisterPostion(RegisterPostionEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnRegisterPostion",
    (ScriptedPuppet_OnRegisterPostion x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnRegisterPostion(
    ScriptedPuppet self,
    RegisterPostionEvent? evt
);

bool OnRevealRequest(RevealRequestEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnRevealRequest",
    (ScriptedPuppet_OnRevealRequest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnRevealRequest(
    ScriptedPuppet self,
    RevealRequestEvent? evt
);

void RequestRevealOutline(bool shouldIncreaseCounter, ent.EntityID requester) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "RequestRevealOutline;BoolEntityID",
    (ScriptedPuppet_RequestRevealOutline x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_RequestRevealOutline(
    ScriptedPuppet self,
    bool shouldIncreaseCounter,
    ent.EntityID requester
);

void ForceVisionAppearanceNetrunner(game.Object target, ent.EntityID sourceID, CName sourceName, bool toggle) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ForceVisionAppearanceNetrunner;GameObjectEntityIDCNameBool",
    (ScriptedPuppet_ForceVisionAppearanceNetrunner x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ForceVisionAppearanceNetrunner(
    ScriptedPuppet self,
    game.Object? target,
    ent.EntityID sourceID,
    CName sourceName,
    bool toggle
);

bool HasQuestItems() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "HasQuestItems;",
    (ScriptedPuppet_HasQuestItems x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_HasQuestItems(
    ScriptedPuppet self
);

bool IsRevealed() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsRevealed;",
    (ScriptedPuppet_IsRevealed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsRevealed(
    ScriptedPuppet self
);

game.data.ReactionPresetType GetPuppetReactionPresetType() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetPuppetReactionPresetType;",
    (ScriptedPuppet_GetPuppetReactionPresetType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ReactionPresetType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetPuppetReactionPresetType(
    ScriptedPuppet self
);

void CreateClearOutlinesRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "CreateClearOutlinesRequest;",
    (ScriptedPuppet_CreateClearOutlinesRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_CreateClearOutlinesRequest(
    ScriptedPuppet self
);

void OnClearOutlinesRequest(ClearOutlinesRequestEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "OnClearOutlinesRequest;ClearOutlinesRequestEvent",
    (ScriptedPuppet_OnClearOutlinesRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnClearOutlinesRequest(
    ScriptedPuppet self,
    ClearOutlinesRequestEvent? evt
);

bool OnOutlineRequestEvent(OutlineRequestEvent evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnOutlineRequestEvent",
    (ScriptedPuppet_OnOutlineRequestEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnOutlineRequestEvent(
    ScriptedPuppet self,
    OutlineRequestEvent? evt
);

void PropagateOutlineToCurrentlyUsedItems(OutlineRequestEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "PropagateOutlineToCurrentlyUsedItems;OutlineRequestEvent",
    (ScriptedPuppet_PropagateOutlineToCurrentlyUsedItems x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_PropagateOutlineToCurrentlyUsedItems(
    ScriptedPuppet self,
    OutlineRequestEvent? evt
);

void PropagateFadeOutlinesRequestToItems() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "PropagateFadeOutlinesRequestToItems;",
    (ScriptedPuppet_PropagateFadeOutlinesRequestToItems x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_PropagateFadeOutlinesRequestToItems(
    ScriptedPuppet self
);

bool GetCurrentlyEquippedItems(game.ItemObject[] heldObjects) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetCurrentlyEquippedItems;script_ref<array<ItemObject>>",
    (ScriptedPuppet_GetCurrentlyEquippedItems x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetCurrentlyEquippedItems(
    ScriptedPuppet self,
    game.ItemObject[] heldObjects
);

bool OnToggleTargetingComponentsEvent(ToggleTargetingComponentsEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnToggleTargetingComponentsEvent",
    (ScriptedPuppet_OnToggleTargetingComponentsEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnToggleTargetingComponentsEvent(
    ScriptedPuppet self,
    ToggleTargetingComponentsEvent? evt
);

bool OnPulseEvent(game.VisionModeUpdateVisuals evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnPulseEvent",
    (ScriptedPuppet_OnPulseEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnPulseEvent(
    ScriptedPuppet self,
    game.VisionModeUpdateVisuals? evt
);

bool OnScanningEvent(game.ScanningEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnScanningEvent",
    (ScriptedPuppet_OnScanningEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnScanningEvent(
    ScriptedPuppet self,
    game.ScanningEvent? evt
);

bool OnScanningLookAtEvent(game.ScanningLookAtEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnScanningLookAtEvent",
    (ScriptedPuppet_OnScanningLookAtEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void UpdateScannerLookAtBB(bool b) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "UpdateScannerLookAtBB;Bool",
    (ScriptedPuppet_UpdateScannerLookAtBB x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool ShouldPulseNetwork() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ShouldPulseNetwork;",
    (ScriptedPuppet_ShouldPulseNetwork x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ShouldPulseNetwork(
    ScriptedPuppet self
);

bool IsBackdoor() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsBackdoor;",
    (ScriptedPuppet_IsBackdoor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsBackdoor(
    ScriptedPuppet self
);

bool IsActiveBackdoor() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsActiveBackdoor;",
    (ScriptedPuppet_IsActiveBackdoor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsActiveBackdoor(
    ScriptedPuppet self
);

bool IsConnectedToBackdoorDevice() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsConnectedToBackdoorDevice;",
    (ScriptedPuppet_IsConnectedToBackdoorDevice x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsConnectedToBackdoorDevice(
    ScriptedPuppet self
);

bool IsNetworkKnownToPlayer() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsNetworkKnownToPlayer;",
    (ScriptedPuppet_IsNetworkKnownToPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsNetworkKnownToPlayer(
    ScriptedPuppet self
);

bool IsHackingPlayer() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsHackingPlayer;",
    (ScriptedPuppet_IsHackingPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsHackingPlayer(
    ScriptedPuppet self
);

bool IsQuickHackAble() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsQuickHackAble;",
    (ScriptedPuppet_IsQuickHackAble x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsQuickHackAble(
    ScriptedPuppet self
);

bool IsQuickHacksExposed() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsQuickHacksExposed;",
    (ScriptedPuppet_IsQuickHacksExposed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsQuickHacksExposed(
    ScriptedPuppet self
);

bool IsBreached() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsBreached;",
    (ScriptedPuppet_IsBreached x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsBreached(
    ScriptedPuppet self
);

CName GetNetworkLinkSlotName() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetNetworkLinkSlotName;",
    (ScriptedPuppet_GetNetworkLinkSlotName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetNetworkLinkSlotName(
    ScriptedPuppet self
);

CName GetNetworkLinkSlotName(out WorldTransform transform) overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetNetworkLinkSlotName;WorldTransform",
    (ScriptedPuppet_GetNetworkLinkSlotName2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetNetworkLinkSlotName2(
    ScriptedPuppet self,
    WorldTransform transform
);

bool IsNetworkLinkDynamic() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsNetworkLinkDynamic;",
    (ScriptedPuppet_IsNetworkLinkDynamic x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsNetworkLinkDynamic(
    ScriptedPuppet self
);

bool ShouldShowScanner() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ShouldShowScanner;",
    (ScriptedPuppet_ShouldShowScanner x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ShouldShowScanner(
    ScriptedPuppet self
);

void StartPingingNetwork() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "StartPingingNetwork;",
    (ScriptedPuppet_StartPingingNetwork x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_StartPingingNetwork(
    ScriptedPuppet self
);

void PulseNetwork(bool revealNetworkAtEnd) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "PulseNetwork;Bool",
    (ScriptedPuppet_PulseNetwork x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_PulseNetwork(
    ScriptedPuppet self,
    bool revealNetworkAtEnd
);

bool OnRevealNetworkGridOnPulse(RevealNetworkGridOnPulse evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnRevealNetworkGridOnPulse",
    (ScriptedPuppet_OnRevealNetworkGridOnPulse x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnRevealNetworkGridOnPulse(
    ScriptedPuppet self,
    RevealNetworkGridOnPulse? evt
);

bool CanOverrideNetworkContext() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "CanOverrideNetworkContext;",
    (ScriptedPuppet_CanOverrideNetworkContext x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_CanOverrideNetworkContext(
    ScriptedPuppet self
);

void StopPingingNetwork() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "StopPingingNetwork;",
    (ScriptedPuppet_StopPingingNetwork x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_StopPingingNetwork(
    ScriptedPuppet self
);

game.FxResource GetFxResourceByKey(CName key) overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetFxResourceByKey;CName",
    (ScriptedPuppet_GetFxResourceByKey x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.FxResource>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetFxResourceByKey(
    ScriptedPuppet self,
    CName key
);

bool OnSetExposeQuickHacks(SetExposeQuickHacks evt) RTTI

Generated hook

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

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

PuppetDeviceLinkPS? GetDeviceLink() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetDeviceLink;",
    (ScriptedPuppet_GetDeviceLink x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.PuppetDeviceLinkPS>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetDeviceLink(
    ScriptedPuppet self
);

bool OnAccessPointMiniGameStatus(game.ui.AccessPointMiniGameStatus evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnAccessPointMiniGameStatus",
    (ScriptedPuppet_OnAccessPointMiniGameStatus x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnAccessPointMiniGameStatus(
    ScriptedPuppet self,
    game.ui.AccessPointMiniGameStatus? evt
);

void OnDiveFinished(CName reason) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "OnDiveFinished;CName",
    (ScriptedPuppet_OnDiveFinished x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnDiveFinished(
    ScriptedPuppet self,
    CName reason
);

game.IBlackboard? GetNetworkBlackboard() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetNetworkBlackboard;",
    (ScriptedPuppet_GetNetworkBlackboard x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IBlackboard>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetNetworkBlackboard(
    ScriptedPuppet self
);

NetworkBlackboardDef? GetNetworkBlackboardDef() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetNetworkBlackboardDef;",
    (ScriptedPuppet_GetNetworkBlackboardDef x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.NetworkBlackboardDef>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetNetworkBlackboardDef(
    ScriptedPuppet self
);

bool OnRevealDeviceRequest(RevealDeviceRequest evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnRevealDeviceRequest",
    (ScriptedPuppet_OnRevealDeviceRequest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnRevealDeviceRequest(
    ScriptedPuppet self,
    RevealDeviceRequest? evt
);

bool OnSetBloodPuddleSettingsEvent(SetBloodPuddleSettingsEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnSetBloodPuddleSettingsEvent",
    (ScriptedPuppet_OnSetBloodPuddleSettingsEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnSetBloodPuddleSettingsEvent(
    ScriptedPuppet self,
    SetBloodPuddleSettingsEvent? evt
);

bool ShouldSpawnBloodPuddle() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ShouldSpawnBloodPuddle;",
    (ScriptedPuppet_ShouldSpawnBloodPuddle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ShouldSpawnBloodPuddle(
    ScriptedPuppet self
);

bool OnBloodPuddleEvent(BloodPuddleEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnBloodPuddleEvent",
    (ScriptedPuppet_OnBloodPuddleEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnBloodPuddleEvent(
    ScriptedPuppet self,
    BloodPuddleEvent? evt
);

bool ShouldSkipDeathAnimation() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ShouldSkipDeathAnimation;",
    (ScriptedPuppet_ShouldSkipDeathAnimation x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ShouldSkipDeathAnimation(
    ScriptedPuppet self
);

void SetSkipDeathAnimation(bool value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "SetSkipDeathAnimation;Bool",
    (ScriptedPuppet_SetSkipDeathAnimation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool IsConnectedToSecuritySystem() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsConnectedToSecuritySystem;",
    (ScriptedPuppet_IsConnectedToSecuritySystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsConnectedToSecuritySystem(
    ScriptedPuppet self
);

bool IsTargetTresspassingMyZone(game.Object target) overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsTargetTresspassingMyZone;GameObject",
    (ScriptedPuppet_IsTargetTresspassingMyZone x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

ESecurityAreaType GetDeterminatedSecurityAreaType() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetDeterminatedSecurityAreaType;",
    (ScriptedPuppet_GetDeterminatedSecurityAreaType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ESecurityAreaType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetDeterminatedSecurityAreaType(
    ScriptedPuppet self
);

ESecuritySystemState MySecuritySystemState() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "MySecuritySystemState;",
    (ScriptedPuppet_MySecuritySystemState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ESecuritySystemState>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_MySecuritySystemState(
    ScriptedPuppet self
);

SecuritySystemControllerPS? GetSecuritySystem() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetSecuritySystem(
    ScriptedPuppet self
);

bool OnSuppressNPCInSecuritySystem(SuppressNPCInSecuritySystem evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnSuppressNPCInSecuritySystem",
    (ScriptedPuppet_OnSuppressNPCInSecuritySystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnSuppressNPCInSecuritySystem(
    ScriptedPuppet self,
    SuppressNPCInSecuritySystem? evt
);

void TriggerSecuritySystemNotification(Vector4 lastKnownPosition, WeakHandle<game.Object> threat, ESecurityNotificationType type, game.data.StimType? stimType)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "TriggerSecuritySystemNotification;Vector4GameObjectESecurityNotificationTypegamedataStimType",
    (ScriptedPuppet_TriggerSecuritySystemNotification x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_TriggerSecuritySystemNotification(
    ScriptedPuppet self,
    Vector4 lastKnownPosition,
    WeakHandle<game.Object> threat,
    ESecurityNotificationType type,
    game.data.StimType? stimType
);

void OnSecuritySupportThreshold(bool above) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "OnSecuritySupportThreshold;Bool",
    (ScriptedPuppet_OnSecuritySupportThreshold x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnSecuritySupportThreshold(
    ScriptedPuppet self,
    bool above
);

bool OnSecurityAreaCrossingPerimeter(SecurityAreaCrossingPerimeter evt) RTTI

Generated hook

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

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

bool OnItemAddedToSlot(game.AttachmentSlotEventsItemAddedToSlot evt) RTTI

Generated hook

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

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

bool OnItemRemovedFromSlot(game.AttachmentSlotEventsItemRemovedFromSlot evt) RTTI

Generated hook

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

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

void HandleSquadAction(CName actionName, EAISquadVerb verb) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "HandleSquadAction;CNameEAISquadVerb",
    (ScriptedPuppet_HandleSquadAction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_HandleSquadAction(
    ScriptedPuppet self,
    CName actionName,
    EAISquadVerb verb
);

void OnSignalSquadActionSignal(ushort signalId, bool newValue) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "OnSignalSquadActionSignal;Uint16Bool",
    (ScriptedPuppet_OnSignalSquadActionSignal x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnSignalSquadActionSignal(
    ScriptedPuppet self,
    ushort signalId,
    bool newValue
);

void OnSignalNPCStateChangeSignal(ushort signalId, bool newValue, NPCStateChangeSignal userData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "OnSignalNPCStateChangeSignal;Uint16BoolNPCStateChangeSignal",
    (ScriptedPuppet_OnSignalNPCStateChangeSignal x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnSignalNPCStateChangeSignal(
    ScriptedPuppet self,
    ushort signalId,
    bool newValue,
    NPCStateChangeSignal? userData
);

void OnSignalForcedRagdollDeathSignal(ushort signalId, bool newValue, ForcedRagdollDeathSignal userData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "OnSignalForcedRagdollDeathSignal;Uint16BoolForcedRagdollDeathSignal",
    (ScriptedPuppet_OnSignalForcedRagdollDeathSignal x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnSignalForcedRagdollDeathSignal(
    ScriptedPuppet self,
    ushort signalId,
    bool newValue,
    ForcedRagdollDeathSignal? userData
);

EGameplayRole DeterminGameplayRole() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "DeterminGameplayRole;",
    (ScriptedPuppet_DeterminGameplayRole x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EGameplayRole>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_DeterminGameplayRole(
    ScriptedPuppet self
);

void ResolveQualityRangeInteractionLayer() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ResolveQualityRangeInteractionLayer;",
    (ScriptedPuppet_ResolveQualityRangeInteractionLayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ResolveQualityRangeInteractionLayer(
    ScriptedPuppet self
);

bool IsQualityRangeInteractionLayer(CName layerTag) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsQualityRangeInteractionLayer;CName",
    (ScriptedPuppet_IsQualityRangeInteractionLayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsQualityRangeInteractionLayer(
    ScriptedPuppet self,
    CName layerTag
);

void UpdateLootInteraction() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "UpdateLootInteraction;",
    (ScriptedPuppet_UpdateLootInteraction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_UpdateLootInteraction(
    ScriptedPuppet self
);

void EvaluateLootQualityEvent() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "EvaluateLootQualityEvent;",
    (ScriptedPuppet_EvaluateLootQualityEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_EvaluateLootQualityEvent(
    ScriptedPuppet self
);

bool OnEvaluateLootQuality(game.events.EvaluateLootQualityEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnEvaluateLootQuality",
    (ScriptedPuppet_OnEvaluateLootQuality x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnEvaluateLootQuality(
    ScriptedPuppet self,
    game.events.EvaluateLootQualityEvent? evt
);

bool EvaluateLootQuality() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "EvaluateLootQuality;",
    (ScriptedPuppet_EvaluateLootQuality x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_EvaluateLootQuality(
    ScriptedPuppet self
);

game.data.Quality GetLootQuality() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetLootQuality;",
    (ScriptedPuppet_GetLootQuality x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Quality>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetLootQuality(
    ScriptedPuppet self
);

bool GetIsIconic() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetIsIconic;",
    (ScriptedPuppet_GetIsIconic x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetIsIconic(
    ScriptedPuppet self
);

bool IsContainer() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsContainer;",
    (ScriptedPuppet_IsContainer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsContainer(
    ScriptedPuppet self
);

bool HasLoot() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "HasLoot;",
    (ScriptedPuppet_HasLoot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_HasLoot(
    ScriptedPuppet self
);

bool HasValidLootQuality() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "HasValidLootQuality;",
    (ScriptedPuppet_HasValidLootQuality x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_HasValidLootQuality(
    ScriptedPuppet self
);

bool OnInventoryEmptyEvent(game.OnInventoryEmptyEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnInventoryEmptyEvent",
    (ScriptedPuppet_OnInventoryEmptyEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnInventoryEmptyEvent(
    ScriptedPuppet self,
    game.OnInventoryEmptyEvent? evt
);

bool OnItemRemovedEvent(game.ItemBeingRemovedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnItemRemovedEvent",
    (ScriptedPuppet_OnItemRemovedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnItemRemovedEvent(
    ScriptedPuppet self,
    game.ItemBeingRemovedEvent? evt
);

bool OnItemAddedEvent(game.ItemAddedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnItemAddedEvent",
    (ScriptedPuppet_OnItemAddedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnItemAddedEvent(
    ScriptedPuppet self,
    game.ItemAddedEvent? evt
);

bool OnInventoryChangedEvent(game.InventoryChangedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnInventoryChangedEvent",
    (ScriptedPuppet_OnInventoryChangedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnInventoryChangedEvent(
    ScriptedPuppet self,
    game.InventoryChangedEvent? evt
);

FocusForcedHighlightData? GetDefaultHighlight() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetDefaultHighlight(
    ScriptedPuppet self
);

bool IsChimera() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsChimera;",
    (ScriptedPuppet_IsChimera x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsChimera(
    ScriptedPuppet self
);

FocusForcedHighlightData? GetChimeraHighlight() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetChimeraHighlight;",
    (ScriptedPuppet_GetChimeraHighlight x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.FocusForcedHighlightData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetChimeraHighlight(
    ScriptedPuppet self
);

EFocusOutlineType GetCurrentOutline() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetCurrentOutline(
    ScriptedPuppet self
);

bool OnRevealStateChanged(RevealStateChangedEvent evt) RTTI

Generated hook

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

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

bool OnHUDInstruction(HUDInstruction evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnHUDInstruction",
    (ScriptedPuppet_OnHUDInstruction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnHUDInstruction(
    ScriptedPuppet self,
    HUDInstruction? evt
);

bool OnHit(game.events.HitEvent evt) overrideRTTI

Generated hook

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

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

void DamagePipelineFinalized(game.events.HitEvent evt) overrideRTTI

Generated hook

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

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

void PuppetDamagePipelineFinalized(game.events.HitEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "PuppetDamagePipelineFinalized;gameHitEvent",
    (ScriptedPuppet_PuppetDamagePipelineFinalized x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void HandleStimsOnHit(game.events.HitEvent evt) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "HandleStimsOnHit;gameHitEvent",
    (ScriptedPuppet_HandleStimsOnHit x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

float GetLastDamageTimeFrom(game.Object threat, out bool isMelee) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetLastDamageTimeFrom;GameObjectBool",
    (ScriptedPuppet_GetLastDamageTimeFrom x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetLastDamageTimeFrom(
    ScriptedPuppet self,
    game.Object? threat,
    bool isMelee
);

CName GetGender() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetGender;",
    (ScriptedPuppet_GetGender x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetGender(
    ScriptedPuppet self
);

bool ShouldRegisterToHUD() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ShouldRegisterToHUD;",
    (ScriptedPuppet_ShouldRegisterToHUD x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ShouldRegisterToHUD(
    ScriptedPuppet self
);

bool CanRevealRemoteActionsWheel() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "CanRevealRemoteActionsWheel;",
    (ScriptedPuppet_CanRevealRemoteActionsWheel x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_CanRevealRemoteActionsWheel(
    ScriptedPuppet self
);

bool HasDirectActionsActive() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "HasDirectActionsActive;",
    (ScriptedPuppet_HasDirectActionsActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_HasDirectActionsActive(
    ScriptedPuppet self
);

int GetBlackboardIntVariable(game.bb.ScriptID_Int32 id) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetBlackboardIntVariable;BlackboardID_Int",
    (ScriptedPuppet_GetBlackboardIntVariable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetBlackboardIntVariable(
    ScriptedPuppet self,
    game.bb.ScriptID_Int32 id
);

void SendQuickhackCommands(bool shouldOpen) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "SendQuickhackCommands;Bool",
    (ScriptedPuppet_SendQuickhackCommands x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_SendQuickhackCommands(
    ScriptedPuppet self,
    bool shouldOpen
);

float GetPingDuration() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetPingDuration;",
    (ScriptedPuppet_GetPingDuration x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetPingDuration(
    ScriptedPuppet self
);

float GetQuickHackDuration(TDBID quickHackID, WeakHandle<game.Object> rootObject, game.StatsObjectID targetID, ent.EntityID instigatorID)

RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetQuickHackDuration;TweakDBIDGameObjectStatsObjectIDEntityID",
    (ScriptedPuppet_GetQuickHackDuration x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetQuickHackDuration(
    ScriptedPuppet self,
    TDBID quickHackID,
    WeakHandle<game.Object> rootObject,
    game.StatsObjectID targetID,
    ent.EntityID instigatorID
);

float GetQuickHackDuration(WeakHandle<game.data.ObjectAction_Record> quickHackRecord, WeakHandle<game.Object> rootObject, game.StatsObjectID targetID, ent.EntityID instigatorID)

RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetQuickHackDuration;ObjectAction_RecordGameObjectStatsObjectIDEntityID",
    (ScriptedPuppet_GetQuickHackDuration2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetQuickHackDuration2(
    ScriptedPuppet self,
    WeakHandle<game.data.ObjectAction_Record> quickHackRecord,
    WeakHandle<game.Object> rootObject,
    game.StatsObjectID targetID,
    ent.EntityID instigatorID
);

float GetObjectActionEffectDurationValue(game.data.HackCategory category, WeakHandle<game.data.ObjectActionEffect_Record>[] durationMods, WeakHandle<game.Object> rootObject, game.StatsObjectID targetID, ent.EntityID instigatorID)

RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetObjectActionEffectDurationValue;gamedataHackCategoryscript_ref<array<ObjectActionEffect_Record>>GameObjectStatsObjectIDEntityID",
    (ScriptedPuppet_GetObjectActionEffectDurationValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetObjectActionEffectDurationValue(
    ScriptedPuppet self,
    game.data.HackCategory category,
    WeakHandle<game.data.ObjectActionEffect_Record>[] durationMods,
    WeakHandle<game.Object> rootObject,
    game.StatsObjectID targetID,
    ent.EntityID instigatorID
);

float GetQuickHackDurationFromLongestEffect(WeakHandle<game.data.ObjectAction_Record> quickHackRecord, WeakHandle<game.Object> rootObject, game.StatsObjectID targetID, ent.EntityID instigatorID)

RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetQuickHackDurationFromLongestEffect;ObjectAction_RecordGameObjectStatsObjectIDEntityID",
    (ScriptedPuppet_GetQuickHackDurationFromLongestEffect x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetQuickHackDurationFromLongestEffect(
    ScriptedPuppet self,
    WeakHandle<game.data.ObjectAction_Record> quickHackRecord,
    WeakHandle<game.Object> rootObject,
    game.StatsObjectID targetID,
    ent.EntityID instigatorID
);

void TranslateChoicesIntoQuickSlotCommands(PuppetAction[] puppetActions, QuickhackData[] commands) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "TranslateChoicesIntoQuickSlotCommands;script_ref<array<PuppetAction>>script_ref<array<QuickhackData>>",
    (ScriptedPuppet_TranslateChoicesIntoQuickSlotCommands x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_TranslateChoicesIntoQuickSlotCommands(
    ScriptedPuppet self,
    PuppetAction[] puppetActions,
    QuickhackData[] commands
);

WeakHandle<game.data.StatusEffect_Record>[] GetIgnoredDurationStats() RTTI

float GetICELevel() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetICELevel;",
    (ScriptedPuppet_GetICELevel x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetICELevel(
    ScriptedPuppet self
);

bool OnQuickSlotCommandUsed(QuickSlotCommandUsed evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnQuickSlotCommandUsed",
    (ScriptedPuppet_OnQuickSlotCommandUsed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnQuickSlotCommandUsed(
    ScriptedPuppet self,
    QuickSlotCommandUsed? evt
);

bool OnQuickHackPanelStateChanged(QuickHackPanelStateEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnQuickHackPanelStateChanged",
    (ScriptedPuppet_OnQuickHackPanelStateChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnQuickHackPanelStateChanged(
    ScriptedPuppet self,
    QuickHackPanelStateEvent? evt
);

bool HasActiveQuickHackUpload() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "HasActiveQuickHackUpload;",
    (ScriptedPuppet_HasActiveQuickHackUpload x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_HasActiveQuickHackUpload(
    ScriptedPuppet self
);

bool IsInvestigating() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsInvestigating;",
    (ScriptedPuppet_IsInvestigating x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsInvestigating(
    ScriptedPuppet self
);

bool IsInvestigatingObject(game.Object objectt) overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsInvestigatingObject;GameObject",
    (ScriptedPuppet_IsInvestigatingObject x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsInvestigatingObject(
    ScriptedPuppet self,
    game.Object? objectt
);

void DetermineInteractionState() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "DetermineInteractionState;",
    (ScriptedPuppet_DetermineInteractionState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_DetermineInteractionState(
    ScriptedPuppet self
);

bool ShouldEnableRemoteLayer() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ShouldEnableRemoteLayer;",
    (ScriptedPuppet_ShouldEnableRemoteLayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ShouldEnableRemoteLayer(
    ScriptedPuppet self
);

WeakHandle<game.Object>[] GetObjectToForwardHighlight() overrideRTTI

void SetSenseObjectType(game.data.SenseObjectType type) RTTI

Generated hook

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

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

bool HasPrimaryOrSecondaryEquipment() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "HasPrimaryOrSecondaryEquipment;",
    (ScriptedPuppet_HasPrimaryOrSecondaryEquipment x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_HasPrimaryOrSecondaryEquipment(
    ScriptedPuppet self
);

void SetMainTrackedObject(game.Object target) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "SetMainTrackedObject;GameObject",
    (ScriptedPuppet_SetMainTrackedObject x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

float GetDistToTraceEndFromPosToMainTrackedObject(sense.AdditionalTraceType traceSource) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetDistToTraceEndFromPosToMainTrackedObject(
    ScriptedPuppet self,
    sense.AdditionalTraceType traceSource
);

bool OnStartEndPhoneCallEvent(StartEndPhoneCallEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnStartEndPhoneCallEvent",
    (ScriptedPuppet_OnStartEndPhoneCallEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnStartEndPhoneCallEvent(
    ScriptedPuppet self,
    StartEndPhoneCallEvent? evt
);

bool OnPauseResumePhoneCallEvent(PauseResumePhoneCallEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnPauseResumePhoneCallEvent",
    (ScriptedPuppet_OnPauseResumePhoneCallEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnPauseResumePhoneCallEvent(
    ScriptedPuppet self,
    PauseResumePhoneCallEvent? evt
);

void ShowPhoneCallDuration(float duration, game.data.StatType statType, game.data.StatPoolType statPoolType, TDBID statPoolID)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ShowPhoneCallDuration;FloatgamedataStatTypegamedataStatPoolTypeTweakDBID",
    (ScriptedPuppet_ShowPhoneCallDuration x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ShowPhoneCallDuration(
    ScriptedPuppet self,
    float duration,
    game.data.StatType statType,
    game.data.StatPoolType statPoolType,
    TDBID statPoolID
);

void PausePhoneCallDuration(game.data.StatPoolType statPoolType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "PausePhoneCallDuration;gamedataStatPoolType",
    (ScriptedPuppet_PausePhoneCallDuration x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_PausePhoneCallDuration(
    ScriptedPuppet self,
    game.data.StatPoolType statPoolType
);

void ResumePhoneCallDuration(game.data.StatPoolType statPoolType, float initialDuration) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ResumePhoneCallDuration;gamedataStatPoolTypeFloat",
    (ScriptedPuppet_ResumePhoneCallDuration x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ResumePhoneCallDuration(
    ScriptedPuppet self,
    game.data.StatPoolType statPoolType,
    float initialDuration
);

void HidePhoneCallDuration(game.data.StatPoolType statPoolType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "HidePhoneCallDuration;gamedataStatPoolType",
    (ScriptedPuppet_HidePhoneCallDuration x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_HidePhoneCallDuration(
    ScriptedPuppet self,
    game.data.StatPoolType statPoolType
);

bool OnUploadProgressStateChanged(UploadProgramProgressEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnUploadProgressStateChanged",
    (ScriptedPuppet_OnUploadProgressStateChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnUploadProgressStateChanged(
    ScriptedPuppet self,
    UploadProgramProgressEvent? evt
);

void ActivateIntelligencePerks(ScriptableDeviceAction action) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ActivateIntelligencePerks;ScriptableDeviceAction",
    (ScriptedPuppet_ActivateIntelligencePerks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ActivateIntelligencePerks(
    ScriptedPuppet self,
    ScriptableDeviceAction? action
);

CName GetPhoneCallIndicatorSlotName() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetPhoneCallIndicatorSlotName;",
    (ScriptedPuppet_GetPhoneCallIndicatorSlotName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetPhoneCallIndicatorSlotName(
    ScriptedPuppet self
);

bool IsPerformingCallReinforcements() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsPerformingCallReinforcements;",
    (ScriptedPuppet_IsPerformingCallReinforcements x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsPerformingCallReinforcements(
    ScriptedPuppet self
);

bool OnMinigameFailEvent(MinigameFailEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnMinigameFailEvent",
    (ScriptedPuppet_OnMinigameFailEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnMinigameFailEvent(
    ScriptedPuppet self,
    MinigameFailEvent? evt
);

void CreateObjectActionsCallbackController(WeakHandle<ent.Entity> instigator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "CreateObjectActionsCallbackController;Entity",
    (ScriptedPuppet_CreateObjectActionsCallbackController x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_CreateObjectActionsCallbackController(
    ScriptedPuppet self,
    WeakHandle<ent.Entity> instigator
);

void DestroyObjectActionsCallbackController() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "DestroyObjectActionsCallbackController;",
    (ScriptedPuppet_DestroyObjectActionsCallbackController x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_DestroyObjectActionsCallbackController(
    ScriptedPuppet self
);

bool OnObjectActionRefreshEvent(game.ObjectActionRefreshEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnObjectActionRefreshEvent",
    (ScriptedPuppet_OnObjectActionRefreshEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnObjectActionRefreshEvent(
    ScriptedPuppet self,
    game.ObjectActionRefreshEvent? evt
);

void HandleChainLightningEffectAndDamageTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "HandleChainLightningEffectAndDamageTask;ScriptTaskData",
    (ScriptedPuppet_HandleChainLightningEffectAndDamageTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

GameplayRoleComponent? GetGameplayRoleComponent() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetGameplayRoleComponent;",
    (ScriptedPuppet_GetGameplayRoleComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.GameplayRoleComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetGameplayRoleComponent(
    ScriptedPuppet self
);

int GetDeviceActionQueueSize() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetDeviceActionQueueSize;",
    (ScriptedPuppet_GetDeviceActionQueueSize x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetDeviceActionQueueSize(
    ScriptedPuppet self
);

int GetDeviceActionMaxQueueSize() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetDeviceActionMaxQueueSize;",
    (ScriptedPuppet_GetDeviceActionMaxQueueSize x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetDeviceActionMaxQueueSize(
    ScriptedPuppet self
);

CName[] GetDeviceActionQueueNames() RTTI

bool IsActionQueueEnabled() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsActionQueueEnabled;",
    (ScriptedPuppet_IsActionQueueEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsActionQueueEnabled(
    ScriptedPuppet self
);

void SetCurrentlyUploadingAction(ScriptableDeviceAction action) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "SetCurrentlyUploadingAction;ScriptableDeviceAction",
    (ScriptedPuppet_SetCurrentlyUploadingAction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_SetCurrentlyUploadingAction(
    ScriptedPuppet self,
    ScriptableDeviceAction? action
);

ScriptableDeviceAction? GetCurrentlyUploadingAction() overrideRTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "GetCurrentlyUploadingAction;",
    (ScriptedPuppet_GetCurrentlyUploadingAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ScriptableDeviceAction>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_GetCurrentlyUploadingAction(
    ScriptedPuppet self
);

bool IsActionCurrentlyUploading() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsActionCurrentlyUploading;",
    (ScriptedPuppet_IsActionCurrentlyUploading x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsActionCurrentlyUploading(
    ScriptedPuppet self
);

bool IsActionQueueFull() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "IsActionQueueFull;",
    (ScriptedPuppet_IsActionQueueFull x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_IsActionQueueFull(
    ScriptedPuppet self
);

bool CanNewActionBeQueued() RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "CanNewActionBeQueued;",
    (ScriptedPuppet_CanNewActionBeQueued x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_CanNewActionBeQueued(
    ScriptedPuppet self
);

ScriptableDeviceAction?[] GetActiveQuickhackActionHistory() RTTI
ScriptableDeviceAction?[] GetCompletedQuickhackActionHistory() RTTI

void SetAnimWrappersOnItem(WeakHandle<game.ItemObject> item) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "SetAnimWrappersOnItem;ItemObject",
    (ScriptedPuppet_SetAnimWrappersOnItem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_SetAnimWrappersOnItem(
    ScriptedPuppet self,
    WeakHandle<game.ItemObject> item
);

bool OnApplyNewStatusEffect(ApplyNewStatusEffectEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnApplyNewStatusEffect",
    (ScriptedPuppet_OnApplyNewStatusEffect x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnApplyNewStatusEffect(
    ScriptedPuppet self,
    ApplyNewStatusEffectEvent? evt
);

bool OnRemoveStatusEffect(RemoveStatusEffectEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnRemoveStatusEffect",
    (ScriptedPuppet_OnRemoveStatusEffect x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnRemoveStatusEffect(
    ScriptedPuppet self,
    RemoveStatusEffectEvent? evt
);

bool OnRemoveAllStatusEffectOfTypeEvent(RemoveAllStatusEffectOfTypeEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "OnRemoveAllStatusEffectOfTypeEvent",
    (ScriptedPuppet_OnRemoveAllStatusEffectOfTypeEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_OnRemoveAllStatusEffectOfTypeEvent(
    ScriptedPuppet self,
    RemoveAllStatusEffectOfTypeEvent? evt
);

static void RemoveListener(game.Object obj, PuppetListener listener) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ScriptedPuppet::RemoveListener;GameObjectPuppetListener",
    (ScriptedPuppet_RemoveListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_RemoveListener(
    game.Object? obj,
    PuppetListener? listener
);

static bool IsTurnedOff(game.Object obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::IsTurnedOff;GameObject",
    (ScriptedPuppet_IsTurnedOff x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static WeakHandle<game.weapon.Object> GetWeaponLeft(game.Object obj) staticRTTI global
static WeakHandle<game.weapon.Object> GetActiveWeapon(game.Object obj) staticRTTI global

static void AddListener(game.Object obj, PuppetListener listener) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ScriptedPuppet::AddListener;GameObjectPuppetListener",
    (ScriptedPuppet_AddListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_AddListener(
    game.Object? obj,
    PuppetListener? listener
);

static void SendNameplateVisibleEvent(WeakHandle<game.Object> obj, bool visible) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ScriptedPuppet::SendNameplateVisibleEvent;GameObjectBool",
    (ScriptedPuppet_SendNameplateVisibleEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_SendNameplateVisibleEvent(
    WeakHandle<game.Object> obj,
    bool visible
);

static bool IsDeaf(WeakHandle<game.Object> obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::IsDeaf;GameObject",
    (ScriptedPuppet_IsDeaf x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static void RequestDeviceDebug(game.Object obj, WeakHandle<Device> device) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ScriptedPuppet::RequestDeviceDebug;GameObjectDevice",
    (ScriptedPuppet_RequestDeviceDebug x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_RequestDeviceDebug(
    game.Object? obj,
    WeakHandle<Device> device
);

static void EvaluateLootQuality(WeakHandle<game.Object> self) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ScriptedPuppet::EvaluateLootQuality;GameObject",
    (ScriptedPuppet_EvaluateLootQuality2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

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

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ScriptedPuppet::SendAndroidTurnOffEvent;GameObject",
    (ScriptedPuppet_SendAndroidTurnOffEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static bool IsUnconscious(game.Object obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::IsUnconscious;GameObject",
    (ScriptedPuppet_IsUnconscious x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static bool IsActive(game.Object obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::IsActive;GameObject",
    (ScriptedPuppet_IsActive2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static bool IsBlinded(WeakHandle<game.Object> obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::IsBlinded;GameObject",
    (ScriptedPuppet_IsBlinded x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static void ReevaluateOxygenConsumption(WeakHandle<ScriptedPuppet> puppet) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ScriptedPuppet::ReevaluateOxygenConsumption;ScriptedPuppet",
    (ScriptedPuppet_ReevaluateOxygenConsumption x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static void CreateCustomBlackboard(game.Object obj, game.IBlackboard blackboard) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ScriptedPuppet::CreateCustomBlackboard;GameObjectIBlackboard",
    (ScriptedPuppet_CreateCustomBlackboard x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_CreateCustomBlackboard(
    game.Object? obj,
    game.IBlackboard? blackboard
);

static game.Object? GetGrappleParent(game.Object obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::GetGrappleParent;GameObject",
    (ScriptedPuppet_GetGrappleParent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameObject>();
    }
);

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

static bool IsPlayerFollower(WeakHandle<game.Object> obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::IsPlayerFollower;GameObject",
    (ScriptedPuppet_IsPlayerFollower x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

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

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ScriptedPuppet::SendDefeatedEvent;GameObject",
    (ScriptedPuppet_SendDefeatedEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static bool CanRagdoll(WeakHandle<game.Object> obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::CanRagdoll;GameObject",
    (ScriptedPuppet_CanRagdoll x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static bool CanTripOverRagdolls(WeakHandle<game.Object> obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::CanTripOverRagdolls;GameObject",
    (ScriptedPuppet_CanTripOverRagdolls x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

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

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ScriptedPuppet::SendResurrectEvent;GameObject",
    (ScriptedPuppet_SendResurrectEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static bool SendActionSignal(WeakHandle<ScriptedPuppet> puppet, CName signalName, float duration) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::SendActionSignal;ScriptedPuppetCNameFloat",
    (ScriptedPuppet_SendActionSignal x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_SendActionSignal(
    WeakHandle<ScriptedPuppet> puppet,
    CName signalName,
    float duration
);

static bool IsCharacterPolice(game.Object obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::IsCharacterPolice;GameObject",
    (ScriptedPuppet_IsCharacterPolice2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static void EvaluateApplyingStatusEffectsFromMountedObjectToPlayer(WeakHandle<game.Object> npc, WeakHandle<game.Object> player)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ScriptedPuppet::EvaluateApplyingStatusEffectsFromMountedObjectToPlayer;GameObjectGameObject",
    (ScriptedPuppet_EvaluateApplyingStatusEffectsFromMountedObjectToPlayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static void SetAnimWrappersOnItem(WeakHandle<game.ItemObject> item, CName[] animWrappers) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ScriptedPuppet::SetAnimWrappersOnItem;ItemObjectarray<CName>",
    (ScriptedPuppet_SetAnimWrappersOnItem2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_SetAnimWrappersOnItem2(
    WeakHandle<game.ItemObject> item,
    CName[] animWrappers
);

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

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ScriptedPuppet::SendAndroidTurnOnEvent;GameObject",
    (ScriptedPuppet_SendAndroidTurnOnEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static bool IsNanoWireHacked(game.Object obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::IsNanoWireHacked;GameObject",
    (ScriptedPuppet_IsNanoWireHacked x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static void SetBloodPuddleSettings(game.Object puppet, bool shouldSpawnBloodPuddle) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ScriptedPuppet::SetBloodPuddleSettings;GameObjectBool",
    (ScriptedPuppet_SetBloodPuddleSettings x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_SetBloodPuddleSettings(
    game.Object? puppet,
    bool shouldSpawnBloodPuddle
);

static void DropItemFromSlot(WeakHandle<game.Object> obj, TDBID slot) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ScriptedPuppet::DropItemFromSlot;GameObjectTweakDBID",
    (ScriptedPuppet_DropItemFromSlot x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static bool IsMaxTac(WeakHandle<game.Object> obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::IsMaxTac;GameObject",
    (ScriptedPuppet_IsMaxTac2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static game.Object? GetGrappleChild(game.Object obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::GetGrappleChild;GameObject",
    (ScriptedPuppet_GetGrappleChild x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameObject>();
    }
);

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

static void RevokeAllTicketsForPrevention(ScriptedPuppet puppet) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ScriptedPuppet::RevokeAllTicketsForPrevention;ScriptedPuppet",
    (ScriptedPuppet_RevokeAllTicketsForPrevention x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_RevokeAllTicketsForPrevention(
    ScriptedPuppet? puppet
);

static void CreateCustomBlackboardFromDef(game.Object obj, CustomBlackboardDef blackboardDef) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ScriptedPuppet::CreateCustomBlackboardFromDef;GameObjectCustomBlackboardDef",
    (ScriptedPuppet_CreateCustomBlackboardFromDef x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_CreateCustomBlackboardFromDef(
    game.Object? obj,
    CustomBlackboardDef? blackboardDef
);

static bool IsPlayerCompanion(WeakHandle<game.Object> obj, out WeakHandle<game.Object> companion) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::IsPlayerCompanion;GameObjectGameObject",
    (ScriptedPuppet_IsPlayerCompanion2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static void RequestRevealOutline(game.Object obj, bool doReveal, ent.EntityID whoWantsToReveal) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ScriptedPuppet::RequestRevealOutline;GameObjectBoolEntityID",
    (ScriptedPuppet_RequestRevealOutline2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_RequestRevealOutline2(
    game.Object? obj,
    bool doReveal,
    ent.EntityID whoWantsToReveal
);

static void DropWeaponFromSlot(WeakHandle<game.Object> obj, TDBID slot) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ScriptedPuppet::DropWeaponFromSlot;GameObjectTweakDBID",
    (ScriptedPuppet_DropWeaponFromSlot x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static bool IsPlayerCompanion(WeakHandle<game.Object> obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::IsPlayerCompanion;GameObject",
    (ScriptedPuppet_IsPlayerCompanion3 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static bool ResetActionSignal(WeakHandle<ScriptedPuppet> puppet, CName signalName) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::ResetActionSignal;ScriptedPuppetCName",
    (ScriptedPuppet_ResetActionSignal x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ScriptedPuppet_ResetActionSignal(
    WeakHandle<ScriptedPuppet> puppet,
    CName signalName
);

static bool IsOnOffMeshLink(WeakHandle<game.Object> obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::IsOnOffMeshLink;GameObject",
    (ScriptedPuppet_IsOnOffMeshLink x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static bool IsAlive(game.Object obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::IsAlive;GameObject",
    (ScriptedPuppet_IsAlive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static bool IsBoss(WeakHandle<game.Object> obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::IsBoss;GameObject",
    (ScriptedPuppet_IsBoss2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static WeakHandle<game.weapon.Object> GetWeaponRight(game.Object obj) staticRTTI global

static bool IsBeingGrappled(game.Object obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::IsBeingGrappled;GameObject",
    (ScriptedPuppet_IsBeingGrappled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static void EvaluateLootQualityByTask(WeakHandle<game.Object> self) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "ScriptedPuppet",
    "ScriptedPuppet::EvaluateLootQualityByTask;GameObject",
    (ScriptedPuppet_EvaluateLootQualityByTask2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static bool IsPlayerAround() staticRTTI global

Generated hook

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

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

static bool IsDefeated(game.Object obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "ScriptedPuppet",
    "ScriptedPuppet::IsDefeated;GameObject",
    (ScriptedPuppet_IsDefeated x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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