class

PlayerPuppet

138 properties
419 functions

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

Properties

Property	Type	Offset
`quickSlotsManager`	`QuickSlotsManager?`	`0x420`	scripted
`inspectionComponent`	`InspectionComponent?`	`0x430`	scripted
`enviroDamageRcvComponent`	`game.EnvironmentDamageReceiverComponent?`	`0x440`	scripted
`mountedVehicle`	`WeakHandle<vehicle.BaseObject>`	`0x450`	scripted
`vehicleKnockdownTimestamp`	`float`	`0x460`	scripted
`Phone`	`PlayerPhone?`	`0x468`	scripted
`fppCameraComponent`	`game.FPPCameraComponent?`	`0x478`	scripted
`primaryTargetingComponent`	`game.TargetingComponent?`	`0x488`	scripted
`breachFinderComponent`	`game.BreachFinderComponent?`	`0x498`	scripted
`chaseSpawnComponent`	`game.ChaseSpawnComponent?`	`0x4A8`	scripted
`isInFinisher`	`bool`	`0x4B8`	scripted
`DEBUG_Visualizer`	`DEBUG_VisualizerComponent?`	`0x4C0`	scripted
`Debug_DamageInputRec`	`DEBUG_DamageInputReceiver?`	`0x4D0`	scripted
`highDamageThreshold`	`float`	`0x4E0`	scripted
`medDamageThreshold`	`float`	`0x4E4`	scripted
`lowDamageThreshold`	`float`	`0x4E8`	scripted
`meleeHighDamageThreshold`	`float`	`0x4EC`	scripted
`meleeMedDamageThreshold`	`float`	`0x4F0`	scripted
`meleeLowDamageThreshold`	`float`	`0x4F4`	scripted
`explosionHighDamageThreshold`	`float`	`0x4F8`	scripted
`explosionMedDamageThreshold`	`float`	`0x4FC`	scripted
`explosionLowDamageThreshold`	`float`	`0x500`	scripted
`effectTimeStamp`	`float`	`0x504`	scripted
`curInventoryWeight`	`float`	`0x508`	scripted
`healthVfxBlackboard`	`world.EffectBlackboard?`	`0x510`	scripted
`laserTargettingVfxBlackboard`	`world.EffectBlackboard?`	`0x520`	scripted
`itemLogBlackboard`	`WeakHandle<game.IBlackboard>`	`0x530`	scripted
`interactionDataListener`	`red.CallbackObject?`	`0x540`	scripted
`popupIsModalListener`	`red.CallbackObject?`	`0x550`	scripted
`uiVendorContextListener`	`red.CallbackObject?`	`0x560`	scripted
`uiRadialContextistener`	`red.CallbackObject?`	`0x570`	scripted
`contactsActiveListener`	`red.CallbackObject?`	`0x580`	scripted
`smsMessengerActiveListener`	`red.CallbackObject?`	`0x590`	scripted
`currentVisibleTargetListener`	`red.CallbackObject?`	`0x5A0`	scripted
`lastScanTarget`	`WeakHandle<game.Object>`	`0x5B0`	scripted
`meleeSelectInputProcessed`	`bool`	`0x5C0`	scripted
`waitingForDelayEvent`	`bool`	`0x5C1`	scripted
`randomizedTime`	`float`	`0x5C4`	scripted
`isResetting`	`bool`	`0x5C8`	scripted
`delayEventID`	`game.DelayID`	`0x5CC`	scripted
`resetTickID`	`game.DelayID`	`0x5D4`	scripted
`katanaAnimProgression`	`float`	`0x5DC`	scripted
`coverModifierActive`	`bool`	`0x5E0`	scripted
`workspotDamageReductionActive`	`bool`	`0x5E1`	scripted
`workspotVisibilityReductionActive`	`bool`	`0x5E2`	scripted
`currentPlayerWorkspotTags`	`CName[]`	`0x5E8`	scripted
`incapacitated`	`bool`	`0x5F8`	scripted
`remoteMappinId`	`game.NewMappinID`	`0x600`	scripted
`CPOMissionDataState`	`CPOMissionDataState?`	`0x608`	scripted
`CPOMissionDataBbId`	`red.CallbackObject?`	`0x618`	scripted
`visibilityListener`	`VisibilityStatListener?`	`0x628`	scripted
`secondHeartListener`	`SecondHeartStatListener?`	`0x638`	scripted
`armorStatListener`	`ArmorStatListener?`	`0x648`	scripted
`healthStatListener`	`HealthStatListener?`	`0x658`	scripted
`oxygenStatListener`	`OxygenStatListener?`	`0x668`	scripted
`aimAssistListener`	`AimAssistSettingsListener?`	`0x678`	scripted
`autoRevealListener`	`AutoRevealStatListener?`	`0x688`	scripted
`allStatsListener`	`PlayerPuppetAllStatListener?`	`0x698`	scripted
`rightHandAttachmentSlotListener`	`game.AttachmentSlotsScriptListener?`	`0x6A8`	scripted
`HealingItemsChargeStatListener`	`HealingItemsChargeStatListener?`	`0x6B8`	scripted
`GrenadesChargeStatListener`	`GrenadesChargeStatListener?`	`0x6C8`	scripted
`ProjectileLauncherChargeStatListener`	`ProjectileLauncherChargeStatListener?`	`0x6D8`	scripted
`OpticalCamoChargeStatListener`	`OpticalCamoChargeStatListener?`	`0x6E8`	scripted
`OverclockChargeListener`	`OverclockChargeListener?`	`0x6F8`	scripted
`accessibilityControlsListener`	`AccessibilityControlsListener?`	`0x708`	scripted
`isTalkingOnPhone`	`bool`	`0x718`	scripted
`DataDamageUpdateID`	`game.DelayID`	`0x71C`	scripted
`playerAttachedCallbackID`	`uint`	`0x724`	scripted
`playerDetachedCallbackID`	`uint`	`0x728`	scripted
`callbackHandles`	`red.CallbackObject?[]`	`0x730`	scripted
`numberOfCombatants`	`int`	`0x740`	scripted
`equipmentMeshOverlayEffectName`	`CName`	`0x748`	scripted
`equipmentMeshOverlayEffectTag`	`CName`	`0x750`	scripted
`equipmentMeshOverlaySlots`	`TDBID[]`	`0x758`	scripted
`coverVisibilityPerkBlocked`	`bool`	`0x768`	scripted
`behindCover`	`bool`	`0x769`	scripted
`inCombat`	`bool`	`0x76A`	scripted
`isBeingRevealed`	`bool`	`0x76B`	scripted
`hasBeenDetected`	`bool`	`0x76C`	scripted
`inCrouch`	`bool`	`0x76D`	scripted
`hasKiroshiOpticsFragment`	`bool`	`0x76E`	scripted
`doingQuickMelee`	`bool`	`0x76F`	scripted
`vehicleState`	`game.PSMVehicle`	`0x770`	scripted
`inMountedWeaponVehicle`	`bool`	`0x774`	scripted
`inDriverCombatTPP`	`bool`	`0x775`	scripted
`driverCombatWeaponType`	`game.data.ItemType`	`0x776`	scripted
`isAiming`	`bool`	`0x77A`	scripted
`focusModeActive`	`bool`	`0x77B`	scripted
`customFastForwardPossible`	`bool`	`0x77C`	scripted
`equippedRightHandWeapon`	`WeakHandle<game.weapon.Object>`	`0x780`	scripted
`aimAssistUpdateQueued`	`bool`	`0x790`	scripted
`locomotionState`	`int`	`0x794`	scripted
`leftHandCyberwareState`	`int`	`0x798`	scripted
`meleeWeaponState`	`int`	`0x79C`	scripted
`weaponZoomLevel`	`float`	`0x7A0`	scripted
`controllingDeviceID`	`ent.EntityID`	`0x7A8`	scripted
`gunshotRange`	`float`	`0x7B0`	scripted
`explosionRange`	`float`	`0x7B4`	scripted
`isInBodySlam`	`bool`	`0x7B8`	scripted
`combatGadgetState`	`int`	`0x7BC`	scripted
`sceneTier`	`GameplayTier`	`0x7C0`	scripted
`nextBufferModifier`	`int`	`0x7C4`	scripted
`attackingNetrunnerID`	`ent.EntityID`	`0x7C8`	scripted
`NPCDeathInstigator`	`WeakHandle<NPCPuppet>`	`0x7D0`	scripted
`bestTargettingWeapon`	`WeakHandle<game.weapon.Object>`	`0x7E0`	scripted
`bestTargettingDot`	`float`	`0x7F0`	scripted
`targettingEnemies`	`int`	`0x7F4`	scripted
`isAimingAtFriendly`	`bool`	`0x7F8`	scripted
`isAimingAtChild`	`bool`	`0x7F9`	scripted
`distanceFromTargetSquared`	`float`	`0x7FC`	scripted
`coverRecordID`	`TDBID`	`0x800`	scripted
`damageReductionRecordID`	`TDBID`	`0x808`	scripted
`visReductionRecordID`	`TDBID`	`0x810`	scripted
`lastDmgInflicted`	`EngineTime`	`0x818`	scripted
`critHealthRumblePlayed`	`bool`	`0x820`	scripted
`critHealthRumbleDurationID`	`game.DelayID`	`0x824`	scripted
`lastHealthUpdate`	`float`	`0x82C`	scripted
`staminaListener`	`StaminaListener?`	`0x830`	scripted
`memoryListener`	`MemoryListener?`	`0x840`	scripted
`securityAreaTypeE3HACK`	`ESecurityAreaType`	`0x850`	scripted
`overlappedSecurityZones`	`game.PersistentID[]`	`0x858`	scripted
`interestingFacts`	`InterestingFacts`	`0x868`	scripted
`interestingFactsListenersIds`	`InterestingFactsListenersIds`	`0x870`	scripted
`interestingFactsListenersFunctions`	`InterestingFactsListenersFunctions`	`0x878`	scripted
`visionModeController`	`PlayerVisionModeController?`	`0x880`	scripted
`combatController`	`PlayerCombatController?`	`0x890`	scripted
`handlingModifiers`	`PlayerWeaponHandlingModifiers?`	`0x8A0`	scripted
`cachedGameplayRestrictions`	`TDBID[]`	`0x8B0`	scripted
`delayEndGracePeriodAfterSpawnEventID`	`game.DelayID`	`0x8C0`	scripted
`CWMaskInVehicleInputHeld`	`bool`	`0x8C8`	scripted
`friendlyDevicesHostileToEnemiesLock`	`ScriptReentrantRWLock`	`0x8D0`	scripted
`friendlyDevicesHostileToEnemies`	`ent.EntityID[]`	`0x8E0`	scripted
`pocketRadio`	`PocketRadio?`	`0x8F0`	scripted
`noMovementModifierData`	`game.StatModifierData_Deprecated?[]`	`0x900`	scripted
`registeredFactListeners`	`FactCallbackData[]`	`0x910`	scripted
`bossThatTargetsPlayer`	`ent.EntityID`	`0x920`	scripted
`choiceTokenTextLayerId`	`uint`	`0x928`	scripted
`choiceTokenTextDrawn`	`bool`	`0x92C`	scripted

Functions

bool IsPlayer() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsPlayer(
    PlayerPuppet self
);

bool IsReplacer() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsReplacer(
    PlayerPuppet self
);

bool IsVRReplacer() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsVRReplacer(
    PlayerPuppet self
);

bool IsInGyroTutorial() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsInGyroTutorial(
    PlayerPuppet self
);

bool IsInReplayTutorial() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsInReplayTutorial(
    PlayerPuppet self
);

bool IsJohnnyReplacer() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsJohnnyReplacer(
    PlayerPuppet self
);

bool IsReplicable() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsReplicable(
    PlayerPuppet self
);

CName GetReplicatedStateClass() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetReplicatedStateClass(
    PlayerPuppet self
);

bool IsCoverModifierAdded() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsCoverModifierAdded(
    PlayerPuppet self
);

bool IsWorkspotDamageReductionAdded() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsWorkspotDamageReductionAdded(
    PlayerPuppet self
);

bool IsWorkspotVisibilityReductionActive() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsWorkspotVisibilityReductionActive(
    PlayerPuppet self
);

game.PersistentID[] GetOverlappedSecurityZones() RTTI

bool GetIsInWorkspotFinisher() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetIsInWorkspotFinisher(
    PlayerPuppet self
);

PlayerPuppetPS? GetPS() overrideRTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetPS",
    (PlayerPuppet_GetPS x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.PlayerPuppetPS>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetPS(
    PlayerPuppet self
);

float GetCombatExitTimestamp() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetCombatExitTimestamp;",
    (PlayerPuppet_GetCombatExitTimestamp x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetCombatExitTimestamp(
    PlayerPuppet self
);

bool IsPuppetInCombat() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsPuppetInCombat(
    PlayerPuppet self
);

void SetPermanentFoodBonus(game.data.StatType type, float value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "SetPermanentFoodBonus;gamedataStatTypeFloat",
    (PlayerPuppet_SetPermanentFoodBonus x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SetPermanentFoodBonus(
    PlayerPuppet self,
    game.data.StatType type,
    float value
);

float GetPermanentFoodBonus(game.data.StatType type) RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetPermanentFoodBonus;gamedataStatType",
    (PlayerPuppet_GetPermanentFoodBonus x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetPermanentFoodBonus(
    PlayerPuppet self,
    game.data.StatType type
);

bool OnRequestComponents(ent.EntityRequestComponentsInterface ri) overrideRTTI

Generated hook

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

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

vehicle.CameraManager? FindVehicleCameraManager() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "FindVehicleCameraManager;",
    (PlayerPuppet_FindVehicleCameraManager x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.vehicle.CameraManager>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_FindVehicleCameraManager(
    PlayerPuppet self
);

bool OnTakeControl(ent.EntityResolveComponentsInterface ri) overrideRTTI

Generated hook

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

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

bool OnReleaseControl() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnReleaseControl(
    PlayerPuppet self
);

void GracePeriodAfterSpawn() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "GracePeriodAfterSpawn;",
    (PlayerPuppet_GracePeriodAfterSpawn x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GracePeriodAfterSpawn(
    PlayerPuppet self
);

vehicle.VisualCustomizationComponent? GetVehicleVisualCustomizationComponent() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetVehicleVisualCustomizationComponent;",
    (PlayerPuppet_GetVehicleVisualCustomizationComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.vehicle.VisualCustomizationComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetVehicleVisualCustomizationComponent(
    PlayerPuppet self
);

void UnlockAccessPointPrograms() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UnlockAccessPointPrograms;",
    (PlayerPuppet_UnlockAccessPointPrograms x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_UnlockAccessPointPrograms(
    PlayerPuppet self
);

bool OnMakePlayerVisibleAfterSpawn(EndGracePeriodAfterSpawn evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnMakePlayerVisibleAfterSpawn(
    PlayerPuppet self,
    EndGracePeriodAfterSpawn? evt
);

bool IsAimingAtFriendly() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsAimingAtFriendly(
    PlayerPuppet self
);

bool IsAimingAtChild() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsAimingAtChild(
    PlayerPuppet self
);

float DistanceFromTargetSquared() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "DistanceFromTargetSquared;",
    (PlayerPuppet_DistanceFromTargetSquared x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_DistanceFromTargetSquared(
    PlayerPuppet self
);

void ReevaluateLookAtTarget() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "ReevaluateLookAtTarget;",
    (PlayerPuppet_ReevaluateLookAtTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ReevaluateLookAtTarget(
    PlayerPuppet self
);

void UpdateLookAtObject(game.Object target) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UpdateLookAtObject;GameObject",
    (PlayerPuppet_UpdateLookAtObject x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool OnLookAtObjectChangedEvent(game.targeting.SystemLookAtObjectChangedEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnLookAtObjectChangedEvent(
    PlayerPuppet self,
    game.targeting.SystemLookAtObjectChangedEvent? evt
);

bool OnWeaponEquipEvent(WeaponEquipEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnWeaponEquipEvent(
    PlayerPuppet self,
    WeaponEquipEvent? evt
);

bool OnSetUpEquipmentOverlayEvent(SetUpEquipmentOverlayEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnSetUpEquipmentOverlayEvent(
    PlayerPuppet self,
    SetUpEquipmentOverlayEvent? evt
);

bool OnAppearanceChangeFinishEvent(ent.AppearanceChangeFinishEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnAppearanceChangeFinishEvent(
    PlayerPuppet self,
    ent.AppearanceChangeFinishEvent? evt
);

bool OnSetSlowMoForOnePunchAttackEvent(SetSlowMoForOnePunchAttackEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnSetSlowMoForOnePunchAttackEvent(
    PlayerPuppet self,
    SetSlowMoForOnePunchAttackEvent? evt
);

void SetSlowMo(float slowMoAmount, float slowMoDuration) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "SetSlowMo;FloatFloat",
    (PlayerPuppet_SetSlowMo x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SetSlowMo(
    PlayerPuppet self,
    float slowMoAmount,
    float slowMoDuration
);

bool OnDodgeToAvoidCombatEvent(DodgeToAvoidCombatEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnDodgeToAvoidCombatEvent(
    PlayerPuppet self,
    DodgeToAvoidCombatEvent? evt
);

bool CanAvoidCombat() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_CanAvoidCombat(
    PlayerPuppet self
);

bool CanAvoidCombatWithDodge() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_CanAvoidCombatWithDodge(
    PlayerPuppet self
);

bool CanAvoidCombatWithGag() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_CanAvoidCombatWithGag(
    PlayerPuppet self
);

bool IsCombatStartBufferActive(float buffer) RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "IsCombatStartBufferActive;Float",
    (PlayerPuppet_IsCombatStartBufferActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsCombatStartBufferActive(
    PlayerPuppet self,
    float buffer
);

bool OnActivateOpticalCamoToExitCombatEvent(ExitCombatOnOpticalCamoActivatedEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnActivateOpticalCamoToExitCombatEvent(
    PlayerPuppet self,
    ExitCombatOnOpticalCamoActivatedEvent? evt
);

bool OnEnablePlayerVisibilityEvent(EnablePlayerVisibilityEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnEnablePlayerVisibilityEvent(
    PlayerPuppet self,
    EnablePlayerVisibilityEvent? evt
);

void RemoveInteractionChoices() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "RemoveInteractionChoices;",
    (PlayerPuppet_RemoveInteractionChoices x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_RemoveInteractionChoices(
    PlayerPuppet self
);

void EvaluateApplyingReplacerGameplayRestrictions() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "EvaluateApplyingReplacerGameplayRestrictions;",
    (PlayerPuppet_EvaluateApplyingReplacerGameplayRestrictions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_EvaluateApplyingReplacerGameplayRestrictions(
    PlayerPuppet self
);

void ResolveCachedGameplayRestrictions() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "ResolveCachedGameplayRestrictions;",
    (PlayerPuppet_ResolveCachedGameplayRestrictions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ResolveCachedGameplayRestrictions(
    PlayerPuppet self
);

void AddGameplayRestriction(game.IBlackboard psmBB, TDBID actionRestrictionRecordID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "AddGameplayRestriction;IBlackboardTweakDBID",
    (PlayerPuppet_AddGameplayRestriction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_AddGameplayRestriction(
    PlayerPuppet self,
    game.IBlackboard? psmBB,
    TDBID actionRestrictionRecordID
);

void RemoveGameplayRestriction(game.IBlackboard psmBB, TDBID actionRestrictionRecordID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "RemoveGameplayRestriction;IBlackboardTweakDBID",
    (PlayerPuppet_RemoveGameplayRestriction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_RemoveGameplayRestriction(
    PlayerPuppet self,
    game.IBlackboard? psmBB,
    TDBID actionRestrictionRecordID
);

void CacheGameplayRestriction(TDBID actionRestrictionRecordID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "CacheGameplayRestriction;TweakDBID",
    (PlayerPuppet_CacheGameplayRestriction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_CacheGameplayRestriction(
    PlayerPuppet self,
    TDBID actionRestrictionRecordID
);

void PlayerAttachedCallback(game.Object playerPuppet) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "PlayerAttachedCallback;GameObject",
    (PlayerPuppet_PlayerAttachedCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_PlayerAttachedCallback(
    PlayerPuppet self,
    game.Object? playerPuppet
);

void PlayerDetachedCallback(game.Object playerPuppet) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "PlayerDetachedCallback;GameObject",
    (PlayerPuppet_PlayerDetachedCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_PlayerDetachedCallback(
    PlayerPuppet self,
    game.Object? playerPuppet
);

bool OnGameAttached() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnGameAttached(
    PlayerPuppet self
);

bool OnGameLoadedFactReset(GameLoadedFactReset evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnGameLoadedFactReset(
    PlayerPuppet self,
    GameLoadedFactReset? evt
);

bool OnDetach() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnDetach(
    PlayerPuppet self
);

bool ShouldRegisterToHUD() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ShouldRegisterToHUD(
    PlayerPuppet self
);

game.ItemID GetCWMaskID() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetCWMaskID;",
    (PlayerPuppet_GetCWMaskID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetCWMaskID(
    PlayerPuppet self
);

bool HasCWMask() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_HasCWMask(
    PlayerPuppet self
);

void ExecuteCWMask() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "ExecuteCWMask;",
    (PlayerPuppet_ExecuteCWMask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ExecuteCWMask(
    PlayerPuppet self
);

bool OnAction(game.input.ScriptListenerAction action, game.input.ScriptListenerActionConsumer consumer) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnAction(
    PlayerPuppet self,
    game.input.ScriptListenerAction action,
    game.input.ScriptListenerActionConsumer consumer
);

bool KeybaordAndMouseControlsActive() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_KeybaordAndMouseControlsActive(
    PlayerPuppet self
);

bool HasPrimaryOrSecondaryEquipment() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_HasPrimaryOrSecondaryEquipment(
    PlayerPuppet self
);

void ProcessToggleWalkInput() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "ProcessToggleWalkInput;",
    (PlayerPuppet_ProcessToggleWalkInput x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ProcessToggleWalkInput(
    PlayerPuppet self
);

void IconicCyberwareActivated() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "IconicCyberwareActivated;",
    (PlayerPuppet_IconicCyberwareActivated x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IconicCyberwareActivated(
    PlayerPuppet self
);

void ActivateIconicCyberware() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "ActivateIconicCyberware;",
    (PlayerPuppet_ActivateIconicCyberware x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ActivateIconicCyberware(
    PlayerPuppet self
);

bool IsPhoneCallActive() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsPhoneCallActive(
    PlayerPuppet self
);

void ShowSandevistanBlockedNotification() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "ShowSandevistanBlockedNotification;",
    (PlayerPuppet_ShowSandevistanBlockedNotification x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ShowSandevistanBlockedNotification(
    PlayerPuppet self
);

void ProcessCallVehicleAction(game.input.ActionType type) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "ProcessCallVehicleAction;gameinputActionType",
    (PlayerPuppet_ProcessCallVehicleAction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ProcessCallVehicleAction(
    PlayerPuppet self,
    game.input.ActionType type
);

bool OnMountingEvent(game.mounting.MountingEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnMountingEvent(
    PlayerPuppet self,
    game.mounting.MountingEvent? evt
);

bool OnUnmountingEvent(game.mounting.UnmountingEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnUnmountingEvent(
    PlayerPuppet self,
    game.mounting.UnmountingEvent? evt
);

vehicle.BaseObject? GetMountedVehicle() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetMountedVehicle;",
    (PlayerPuppet_GetMountedVehicle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.vehicle.BaseObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetMountedVehicle(
    PlayerPuppet self
);

bool IsCallingVehicleRestricted() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsCallingVehicleRestricted(
    PlayerPuppet self
);

bool IsInPoliceVehicle() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsInPoliceVehicle(
    PlayerPuppet self
);

int GetUnlockedVehiclesSize() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetUnlockedVehiclesSize;",
    (PlayerPuppet_GetUnlockedVehiclesSize x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetUnlockedVehiclesSize(
    PlayerPuppet self
);

void SendSummonVehicleQuickSlotsManagerRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "SendSummonVehicleQuickSlotsManagerRequest;",
    (PlayerPuppet_SendSummonVehicleQuickSlotsManagerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SendSummonVehicleQuickSlotsManagerRequest(
    PlayerPuppet self
);

bool CheckVehicleSystemGarageState() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_CheckVehicleSystemGarageState(
    PlayerPuppet self
);

bool CheckRadialContextRequest() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_CheckRadialContextRequest(
    PlayerPuppet self
);

void OnActionMultiplayer(game.input.ScriptListenerAction action, game.input.ScriptListenerActionConsumer consumer) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "OnActionMultiplayer;ListenerActionListenerActionConsumer",
    (PlayerPuppet_OnActionMultiplayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnActionMultiplayer(
    PlayerPuppet self,
    game.input.ScriptListenerAction action,
    game.input.ScriptListenerActionConsumer consumer
);

int GetCPOQuickSlotID(game.input.ScriptListenerAction action) RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetCPOQuickSlotID;ListenerAction",
    (PlayerPuppet_GetCPOQuickSlotID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetCPOQuickSlotID(
    PlayerPuppet self,
    game.input.ScriptListenerAction action
);

void UpdatePlayerSettings() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UpdatePlayerSettings;",
    (PlayerPuppet_UpdatePlayerSettings x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_UpdatePlayerSettings(
    PlayerPuppet self
);

QuickSlotsManager? GetQuickSlotsManager() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetQuickSlotsManager;",
    (PlayerPuppet_GetQuickSlotsManager x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.QuickSlotsManager>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetQuickSlotsManager(
    PlayerPuppet self
);

InspectionComponent? GetInspectionComponent() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetInspectionComponent;",
    (PlayerPuppet_GetInspectionComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.InspectionComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetInspectionComponent(
    PlayerPuppet self
);

game.FPPCameraComponent? GetFPPCameraComponent() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetFPPCameraComponent;",
    (PlayerPuppet_GetFPPCameraComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.FPPCameraComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetFPPCameraComponent(
    PlayerPuppet self
);

int GetBufferModifier() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetBufferModifier;",
    (PlayerPuppet_GetBufferModifier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetBufferModifier(
    PlayerPuppet self
);

void SetBufferModifier(int i) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "SetBufferModifier;Int32",
    (PlayerPuppet_SetBufferModifier x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SetBufferModifier(
    PlayerPuppet self,
    int i
);

PlayerWeaponHandlingModifiers? GetPlayerWeaponHandler() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetPlayerWeaponHandler;",
    (PlayerPuppet_GetPlayerWeaponHandler x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.PlayerWeaponHandlingModifiers>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetPlayerWeaponHandler(
    PlayerPuppet self
);

PocketRadio? GetPocketRadio() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetPocketRadio;",
    (PlayerPuppet_GetPocketRadio x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.PocketRadio>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetPocketRadio(
    PlayerPuppet self
);

game.IBlackboard? GetPlayerStateMachineBlackboard() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetPlayerStateMachineBlackboard;",
    (PlayerPuppet_GetPlayerStateMachineBlackboard x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IBlackboard>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetPlayerStateMachineBlackboard(
    PlayerPuppet self
);

game.IBlackboard? GetPlayerPerkDataBlackboard() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetPlayerPerkDataBlackboard;",
    (PlayerPuppet_GetPlayerPerkDataBlackboard x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IBlackboard>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetPlayerPerkDataBlackboard(
    PlayerPuppet self
);

game.IBlackboard? GetHackingDataBlackboard() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetHackingDataBlackboard;",
    (PlayerPuppet_GetHackingDataBlackboard x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IBlackboard>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetHackingDataBlackboard(
    PlayerPuppet self
);

void GetDamageThresholdParams() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "GetDamageThresholdParams;",
    (PlayerPuppet_GetDamageThresholdParams x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetDamageThresholdParams(
    PlayerPuppet self
);

void EnableUIBlackboardListener(bool enable) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "EnableUIBlackboardListener;Bool",
    (PlayerPuppet_EnableUIBlackboardListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_EnableUIBlackboardListener(
    PlayerPuppet self,
    bool enable
);

void SetupInPlayerDevelopmentSystem() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "SetupInPlayerDevelopmentSystem;",
    (PlayerPuppet_SetupInPlayerDevelopmentSystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SetupInPlayerDevelopmentSystem(
    PlayerPuppet self
);

void UpdateVisibilityModifier() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UpdateVisibilityModifier;",
    (PlayerPuppet_UpdateVisibilityModifier x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_UpdateVisibilityModifier(
    PlayerPuppet self
);

bool OnBeingNoticed(OnBeingNoticed evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnBeingNoticed(
    PlayerPuppet self,
    OnBeingNoticed? evt
);

void SetEntityNoticedPlayerBBValue(bool b) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "SetEntityNoticedPlayerBBValue;Bool",
    (PlayerPuppet_SetEntityNoticedPlayerBBValue x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool OnClearBeingNoticedBB(ClearBeingNoticedBB evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnClearBeingNoticedBB(
    PlayerPuppet self,
    ClearBeingNoticedBB? evt
);

bool IsBeingRevealed() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsBeingRevealed(
    PlayerPuppet self
);

void SetIsBeingRevealed(bool isBeingRevealed) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "SetIsBeingRevealed;Bool",
    (PlayerPuppet_SetIsBeingRevealed x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SetIsBeingRevealed(
    PlayerPuppet self,
    bool isBeingRevealed
);

bool OnBeingTargetByLaserSight(BeingTargetByLaserSightUpdateEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnBeingTargetByLaserSight(
    PlayerPuppet self,
    BeingTargetByLaserSightUpdateEvent? evt
);

bool OnBeingTarget(OnBeingTarget evt) RTTI

Generated hook

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

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

bool OnUpdateVisibilityModifierEvent(UpdateVisibilityModifierEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnUpdateVisibilityModifierEvent(
    PlayerPuppet self,
    UpdateVisibilityModifierEvent? evt
);

bool OnUpdateAutoRevealStatEvent(UpdateAutoRevealStatEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnUpdateAutoRevealStatEvent(
    PlayerPuppet self,
    UpdateAutoRevealStatEvent? evt
);

bool HasAutoReveal() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_HasAutoReveal(
    PlayerPuppet self
);

bool OnUIContextChange(bool value) RTTI

Generated hook

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

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

bool OnUIRadialContextChange(bool value) RTTI

Generated hook

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

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

bool OnCurrentVisibleTargetChanged(ent.EntityID targetId) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnCurrentVisibleTargetChanged(
    PlayerPuppet self,
    ent.EntityID targetId
);

bool OnUIContactListContextChanged(bool value) RTTI

Generated hook

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

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

bool OnUISmsMessengerContextChanged(bool value) RTTI

Generated hook

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

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

bool OnUIVendorContextChange(bool value) RTTI

Generated hook

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

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

bool OnExperienceGained(ExperiencePointsEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnExperienceGained(
    PlayerPuppet self,
    ExperiencePointsEvent? evt
);

bool OnLevelUp(LevelUpdateEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnLevelUp(
    PlayerPuppet self,
    LevelUpdateEvent? evt
);

bool OnRequestStats(game.RequestStats evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnRequestStats(
    PlayerPuppet self,
    game.RequestStats? evt
);

bool OnBuyAttribute(RequestBuyAttribute evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnBuyAttribute(
    PlayerPuppet self,
    RequestBuyAttribute? evt
);

bool OnItemAddedToSlot(game.AttachmentSlotEventsItemAddedToSlot evt) overrideRTTI

Generated hook

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

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

bool OnPartAddedToSlotEvent(game.AttachmentSlotEventsPartAddedToSlotEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnPartAddedToSlotEvent(
    PlayerPuppet self,
    game.AttachmentSlotEventsPartAddedToSlotEvent? evt
);

bool OnClearItemAppearanceEvent(ClearItemAppearanceEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnClearItemAppearanceEvent(
    PlayerPuppet self,
    ClearItemAppearanceEvent? evt
);

bool OnResetItemAppearanceEvent(ResetItemAppearanceEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnResetItemAppearanceEvent(
    PlayerPuppet self,
    ResetItemAppearanceEvent? evt
);

bool OnUnderwearEquipFailsafeEvent(UnderwearEquipFailsafeEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnUnderwearEquipFailsafeEvent(
    PlayerPuppet self,
    UnderwearEquipFailsafeEvent? evt
);

bool OnItemRemovedFromSlot(game.AttachmentSlotEventsItemRemovedFromSlot evt) overrideRTTI

Generated hook

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

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

bool OnPartRemovedFromSlotEvent(game.AttachmentSlotEventsPartRemovedFromSlotEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnPartRemovedFromSlotEvent(
    PlayerPuppet self,
    game.AttachmentSlotEventsPartRemovedFromSlotEvent? evt
);

bool OnItemChangedEvent(game.ItemChangedEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnItemChangedEvent(
    PlayerPuppet self,
    game.ItemChangedEvent? evt
);

bool OnPartRemovedEvent(game.PartRemovedEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnPartRemovedEvent(
    PlayerPuppet self,
    game.PartRemovedEvent? evt
);

bool OnPrepareForForcedVehicleCombat(PrepareForForcedVehicleCombat evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnPrepareForForcedVehicleCombat(
    PlayerPuppet self,
    PrepareForForcedVehicleCombat? evt
);

bool OnItemAddedToInventory(game.ItemAddedEvent evt) RTTI

Generated hook

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

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

bool OnRefreshItemPlayerScalingEvent(RefreshItemPlayerScalingEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnRefreshItemPlayerScalingEvent(
    PlayerPuppet self,
    RefreshItemPlayerScalingEvent? evt
);

void TryScaleItemToPlayer(game.ItemData itemData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "TryScaleItemToPlayer;gameItemData",
    (PlayerPuppet_TryScaleItemToPlayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_TryScaleItemToPlayer(
    PlayerPuppet self,
    game.ItemData? itemData
);

bool OnRestoreCybWeaponQualitiesEvent(RestoreCybWeaponQualitiesEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnRestoreCybWeaponQualitiesEvent(
    PlayerPuppet self,
    RestoreCybWeaponQualitiesEvent? evt
);

bool OnRescaleNonIconicWeaponsEvent(RescaleNonIconicWeaponsEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnRescaleNonIconicWeaponsEvent(
    PlayerPuppet self,
    RescaleNonIconicWeaponsEvent? evt
);

void RetroRescaleNonIconicWeapons(game.ItemData itemData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "RetroRescaleNonIconicWeapons;gameItemData",
    (PlayerPuppet_RetroRescaleNonIconicWeapons x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_RetroRescaleNonIconicWeapons(
    PlayerPuppet self,
    game.ItemData? itemData
);

bool OnConsumablesChargesRework(ConsumablesChargesReworkEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnConsumablesChargesRework(
    PlayerPuppet self,
    ConsumablesChargesReworkEvent? evt
);

bool OnBlockAndCompensateScalingEvent(BlockAndCompensateScalingEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnBlockAndCompensateScalingEvent(
    PlayerPuppet self,
    BlockAndCompensateScalingEvent? evt
);

void BlockScaling(game.ItemData itemData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "BlockScaling;gameItemData",
    (PlayerPuppet_BlockScaling x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_BlockScaling(
    PlayerPuppet self,
    game.ItemData? itemData
);

void CompensateExceedScaling(game.ItemData itemData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "CompensateExceedScaling;gameItemData",
    (PlayerPuppet_CompensateExceedScaling x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_CompensateExceedScaling(
    PlayerPuppet self,
    game.ItemData? itemData
);

void SetIconicWeaponsTier(game.ItemData itemData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "SetIconicWeaponsTier;gameItemData",
    (PlayerPuppet_SetIconicWeaponsTier x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SetIconicWeaponsTier(
    PlayerPuppet self,
    game.ItemData? itemData
);

void LockItemPlusOnNonIconicWeapons(game.ItemData itemData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "LockItemPlusOnNonIconicWeapons;gameItemData",
    (PlayerPuppet_LockItemPlusOnNonIconicWeapons x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_LockItemPlusOnNonIconicWeapons(
    PlayerPuppet self,
    game.ItemData? itemData
);

bool OnIconicsReworkCompensateEvent(IconicsReworkCompensateEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnIconicsReworkCompensateEvent(
    PlayerPuppet self,
    IconicsReworkCompensateEvent? evt
);

void RescaleOwnedIconicsToPlayerLevel(game.ItemData itemData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "RescaleOwnedIconicsToPlayerLevel;gameItemData",
    (PlayerPuppet_RescaleOwnedIconicsToPlayerLevel x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_RescaleOwnedIconicsToPlayerLevel(
    PlayerPuppet self,
    game.ItemData? itemData
);

bool OnRasetsuToPlayerScalingEvent(RasetsuToPlayerScalingEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnRasetsuToPlayerScalingEvent(
    PlayerPuppet self,
    RasetsuToPlayerScalingEvent? evt
);

void ScaleRasetsuToProperTier(game.ItemData itemData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "ScaleRasetsuToProperTier;gameItemData",
    (PlayerPuppet_ScaleRasetsuToProperTier x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ScaleRasetsuToProperTier(
    PlayerPuppet self,
    game.ItemData? itemData
);

bool OnUnifyIconicsUpgradeCountWithEffectiveTierEvent(UnifyIconicsUpgradeCountWithEffectiveTierEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnUnifyIconicsUpgradeCountWithEffectiveTierEvent(
    PlayerPuppet self,
    UnifyIconicsUpgradeCountWithEffectiveTierEvent? evt
);

void UnifyIconicWeaponsUpgradesCountWithEffectiveTier(game.ItemData itemData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UnifyIconicWeaponsUpgradesCountWithEffectiveTier;gameItemData",
    (PlayerPuppet_UnifyIconicWeaponsUpgradesCountWithEffectiveTier x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_UnifyIconicWeaponsUpgradesCountWithEffectiveTier(
    PlayerPuppet self,
    game.ItemData? itemData
);

float GetItemCapacityRequirement(game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetItemCapacityRequirement;ItemID",
    (PlayerPuppet_GetItemCapacityRequirement x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

bool OnRetrofixQuickhacksEvent(RetrofixQuickhacksEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnRetrofixQuickhacksEvent(
    PlayerPuppet self,
    RetrofixQuickhacksEvent? evt
);

void GetGlitchedEquippedCyberware(out game.ItemID[] items) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "GetGlitchedEquippedCyberware;array<ItemID>",
    (PlayerPuppet_GetGlitchedEquippedCyberware x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetGlitchedEquippedCyberware(
    PlayerPuppet self,
    game.ItemID[] items
);

bool PrioritizeCyberwareOnRetrofix(game.ItemID itemID, game.data.EquipmentArea equipmentArea, out game.ItemID[] p1, out game.ItemID[] p2, out game.ItemID[] p3, bool beforeVikVisit)

RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "PrioritizeCyberwareOnRetrofix;ItemIDgamedataEquipmentAreaarray<ItemID>array<ItemID>array<ItemID>Bool",
    (PlayerPuppet_PrioritizeCyberwareOnRetrofix x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_PrioritizeCyberwareOnRetrofix(
    PlayerPuppet self,
    game.ItemID itemID,
    game.data.EquipmentArea equipmentArea,
    game.ItemID[] p1,
    game.ItemID[] p2,
    game.ItemID[] p3,
    bool beforeVikVisit
);

game.ItemID[] RemoveCyberwareParts(game.ItemID item) RTTI

bool OnRetrofixCyberwaresEvent(RetrofixCyberwaresEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnRetrofixCyberwaresEvent(
    PlayerPuppet self,
    RetrofixCyberwaresEvent? evt
);

game.data.Item_Record? GetAppropriateCWByQuality(int quality, TDBID baseCWRecord) RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetAppropriateCWByQuality;Int32TweakDBID",
    (PlayerPuppet_GetAppropriateCWByQuality x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Item_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetAppropriateCWByQuality(
    PlayerPuppet self,
    int quality,
    TDBID baseCWRecord
);

float EquipNewCyberware(game.ItemID[] items, float availableCapacity, bool addToInventoryIfOverallocated, game.ItemID[]? stashedQuickhacks)

RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "EquipNewCyberware;array<ItemID>FloatBoolarray<ItemID>",
    (PlayerPuppet_EquipNewCyberware x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_EquipNewCyberware(
    PlayerPuppet self,
    game.ItemID[] items,
    float availableCapacity,
    bool addToInventoryIfOverallocated,
    game.ItemID[]? stashedQuickhacks
);

bool OnRetrofixOverallocatedCyberwareEvent(RetrofixOverallocatedCyberwareEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnRetrofixOverallocatedCyberwareEvent(
    PlayerPuppet self,
    RetrofixOverallocatedCyberwareEvent? evt
);

float UnequipOverallocatedCyberware(game.ItemID[] items, float availableCapacity) RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "UnequipOverallocatedCyberware;array<ItemID>Float",
    (PlayerPuppet_UnequipOverallocatedCyberware x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_UnequipOverallocatedCyberware(
    PlayerPuppet self,
    game.ItemID[] items,
    float availableCapacity
);

void UpdateInventoryWeight(float weightChange, bool? isLootBroken) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UpdateInventoryWeight;FloatBool",
    (PlayerPuppet_UpdateInventoryWeight x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_UpdateInventoryWeight(
    PlayerPuppet self,
    float weightChange,
    bool? isLootBroken
);

bool OnItemBeingRemovedFromInventory(game.ItemBeingRemovedEvent evt) RTTI

Generated hook

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

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

bool OnInventoryEmpty(game.OnInventoryEmptyEvent evt) RTTI

Generated hook

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

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

void EvaluateEncumbrance(bool? isLootBroken) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "EvaluateEncumbrance;Bool",
    (PlayerPuppet_EvaluateEncumbrance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_EvaluateEncumbrance(
    PlayerPuppet self,
    bool? isLootBroken
);

void CalculateEncumbrance() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "CalculateEncumbrance;",
    (PlayerPuppet_CalculateEncumbrance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_CalculateEncumbrance(
    PlayerPuppet self
);

bool OnEvaluateEncumbranceEvent(EvaluateEncumbranceEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnEvaluateEncumbranceEvent(
    PlayerPuppet self,
    EvaluateEncumbranceEvent? evt
);

void SendCheckRemovedItemWithSlotActiveItemRequest(game.ItemID item) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "SendCheckRemovedItemWithSlotActiveItemRequest;ItemID",
    (PlayerPuppet_SendCheckRemovedItemWithSlotActiveItemRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SendCheckRemovedItemWithSlotActiveItemRequest(
    PlayerPuppet self,
    game.ItemID item
);

bool OnTakedownOrder(OrderTakedownEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnTakedownOrder(
    PlayerPuppet self,
    OrderTakedownEvent? evt
);

bool OnSpiderbotOrderTargetEvent(SpiderbotOrderDeviceEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnSpiderbotOrderTargetEvent(
    PlayerPuppet self,
    SpiderbotOrderDeviceEvent? evt
);

void OnHitBlockedOrDeflected(game.events.HitEvent hitEvent) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "OnHitBlockedOrDeflected;gameHitEvent",
    (PlayerPuppet_OnHitBlockedOrDeflected x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void PushDeflectEvent(bool isBulletDeflect) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "PushDeflectEvent;Bool",
    (PlayerPuppet_PushDeflectEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_PushDeflectEvent(
    PlayerPuppet self,
    bool isBulletDeflect
);

bool OnKatanaMagFieldHitDelayEvent(KatanaMagFieldHitDelayEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnKatanaMagFieldHitDelayEvent(
    PlayerPuppet self,
    KatanaMagFieldHitDelayEvent? evt
);

void OnHitAnimation(game.events.HitEvent hitEvent) overrideRTTI

Generated hook

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

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

void AddOnHitRumble(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "AddOnHitRumble;gameHitEvent",
    (PlayerPuppet_AddOnHitRumble x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void PushHitDataToGraph(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "PushHitDataToGraph;gameHitEvent",
    (PlayerPuppet_PushHitDataToGraph x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool OnCameraShakeEvent(game.events.CameraShakeEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnCameraShakeEvent(
    PlayerPuppet self,
    game.events.CameraShakeEvent? evt
);

void SendCameraShakeDataToGraph(game.events.HitEvent? hitEvent, float shakeStrength) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "SendCameraShakeDataToGraph;gameHitEventFloat",
    (PlayerPuppet_SendCameraShakeDataToGraph x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SendCameraShakeDataToGraph(
    PlayerPuppet self,
    game.events.HitEvent? hitEvent,
    float shakeStrength
);

void OnHitUI(game.events.HitEvent hitEvent) overrideRTTI

Generated hook

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

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

void OnHitSounds(game.events.HitEvent hitEvent) overrideRTTI

Generated hook

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

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

bool OnDamageInflicted(DamageInflictedEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnDamageInflicted(
    PlayerPuppet self,
    DamageInflictedEvent? evt
);

EngineTime GetLastDamageInflictedTime() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetLastDamageInflictedTime;",
    (PlayerPuppet_GetLastDamageInflictedTime x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EngineTime>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetLastDamageInflictedTime(
    PlayerPuppet self
);

bool OnInteraction(game.interactions.ChoiceEvent choiceEvent) overrideRTTI

Generated hook

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

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

bool OnTogglePlayerFlashlightEvent(TogglePlayerFlashlightEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnTogglePlayerFlashlightEvent(
    PlayerPuppet self,
    TogglePlayerFlashlightEvent? evt
);

bool OnToggleNewPlayerFlashlightEvent(ToggleNewPlayerFlashlightEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnToggleNewPlayerFlashlightEvent(
    PlayerPuppet self,
    ToggleNewPlayerFlashlightEvent? evt
);

void InitializeTweakDBRecords() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "InitializeTweakDBRecords;",
    (PlayerPuppet_InitializeTweakDBRecords x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_InitializeTweakDBRecords(
    PlayerPuppet self
);

void DefineModifierGroups() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "DefineModifierGroups;",
    (PlayerPuppet_DefineModifierGroups x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_DefineModifierGroups(
    PlayerPuppet self
);

void RegisterStatListeners(PlayerPuppet self) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "RegisterStatListeners;PlayerPuppet",
    (PlayerPuppet_RegisterStatListeners x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void UnregisterStatListeners(PlayerPuppet self) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UnregisterStatListeners;PlayerPuppet",
    (PlayerPuppet_UnregisterStatListeners x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool OnCleanUpTimeDilationEvent(CleanUpTimeDilationEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnCleanUpTimeDilationEvent(
    PlayerPuppet self,
    CleanUpTimeDilationEvent? evt
);

bool OnHealthUpdateEvent(HealthUpdateEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnHealthUpdateEvent(
    PlayerPuppet self,
    HealthUpdateEvent? evt
);

void UpdateHealthStateSFX(float healthValue) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UpdateHealthStateSFX;Float",
    (PlayerPuppet_UpdateHealthStateSFX x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_UpdateHealthStateSFX(
    PlayerPuppet self,
    float healthValue
);

bool OnStopCritHealthRumble(StopCritHealthRumble evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnStopCritHealthRumble(
    PlayerPuppet self,
    StopCritHealthRumble? evt
);

void PlayCritHealthRumble() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "PlayCritHealthRumble;",
    (PlayerPuppet_PlayCritHealthRumble x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_PlayCritHealthRumble(
    PlayerPuppet self
);

void StopCritHealthRumble() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "StopCritHealthRumble;",
    (PlayerPuppet_StopCritHealthRumble x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_StopCritHealthRumble(
    PlayerPuppet self
);

void UpdateHealthStateVFX(float healthValue) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UpdateHealthStateVFX;Float",
    (PlayerPuppet_UpdateHealthStateVFX x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_UpdateHealthStateVFX(
    PlayerPuppet self,
    float healthValue
);

void SetZoomBlackboardValues(bool newState) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "SetZoomBlackboardValues;Bool",
    (PlayerPuppet_SetZoomBlackboardValues x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SetZoomBlackboardValues(
    PlayerPuppet self,
    bool newState
);

bool GetZoomBlackboardValues() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetZoomBlackboardValues(
    PlayerPuppet self
);

bool OnRewardEvent(quest.RewardEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnRewardEvent(
    PlayerPuppet self,
    quest.RewardEvent? evt
);

bool OnManagePersonalLinkChangeEvent(ManagePersonalLinkChangeEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnManagePersonalLinkChangeEvent(
    PlayerPuppet self,
    ManagePersonalLinkChangeEvent? evt
);

bool IsBlackwallForceEquippedOnPlayer() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsBlackwallForceEquippedOnPlayer(
    PlayerPuppet self
);

string GetPhoneCallFactName(CName contactName1, CName contactName2) RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetPhoneCallFactName;CNameCName",
    (PlayerPuppet_GetPhoneCallFactName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetPhoneCallFactName(
    PlayerPuppet self,
    CName contactName1,
    CName contactName2
);

void TriggerInspect(string itemID, float offset, float adsOffset, float timeToScan) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "TriggerInspect;StringFloatFloatFloat",
    (PlayerPuppet_TriggerInspect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_TriggerInspect(
    PlayerPuppet self,
    string itemID,
    float offset,
    float adsOffset,
    float timeToScan
);

void SetInvisible(bool isInvisible) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "SetInvisible;Bool",
    (PlayerPuppet_SetInvisible x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SetInvisible(
    PlayerPuppet self,
    bool isInvisible
);

bool IsInvisible() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsInvisible(
    PlayerPuppet self
);

bool OnHeavyFootstepEvent(HeavyFootstepEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnHeavyFootstepEvent(
    PlayerPuppet self,
    HeavyFootstepEvent? evt
);

void PlayFootstepCameraShakeBasedOnProximity(HeavyFootstepEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "PlayFootstepCameraShakeBasedOnProximity;HeavyFootstepEvent",
    (PlayerPuppet_PlayFootstepCameraShakeBasedOnProximity x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_PlayFootstepCameraShakeBasedOnProximity(
    PlayerPuppet self,
    HeavyFootstepEvent? evt
);

void UpdateVisibility() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UpdateVisibility;",
    (PlayerPuppet_UpdateVisibility x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_UpdateVisibility(
    PlayerPuppet self
);

void UpdateSecondaryVisibilityOffset(bool isCrouching) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UpdateSecondaryVisibilityOffset;Bool",
    (PlayerPuppet_UpdateSecondaryVisibilityOffset x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_UpdateSecondaryVisibilityOffset(
    PlayerPuppet self,
    bool isCrouching
);

void EnableCombatVisibilityDistances(bool enable) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "EnableCombatVisibilityDistances;Bool",
    (PlayerPuppet_EnableCombatVisibilityDistances x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_EnableCombatVisibilityDistances(
    PlayerPuppet self,
    bool enable
);

bool OnZoomLevelChange(float newLevel) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnZoomLevelChange(
    PlayerPuppet self,
    float newLevel
);

bool OnLocomotionStateChanged(int newState) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnLocomotionStateChanged(
    PlayerPuppet self,
    int newState
);

bool OnCombatStateChanged(int newState) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnCombatStateChanged(
    PlayerPuppet self,
    int newState
);

void OnStatChanged(game.StatsObjectID ownerID, game.data.StatType statType, float diff, float total) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "OnStatChanged;StatsObjectIDgamedataStatTypeFloatFloat",
    (PlayerPuppet_OnStatChanged x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnStatChanged(
    PlayerPuppet self,
    game.StatsObjectID ownerID,
    game.data.StatType statType,
    float diff,
    float total
);

void UpdateWeaponRightEquippedItemInfo() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UpdateWeaponRightEquippedItemInfo;",
    (PlayerPuppet_UpdateWeaponRightEquippedItemInfo x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_UpdateWeaponRightEquippedItemInfo(
    PlayerPuppet self
);

void OnItemEquipped(TDBID slot, game.ItemID item) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "OnItemEquipped;TweakDBIDItemID",
    (PlayerPuppet_OnItemEquipped x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnItemEquipped(
    PlayerPuppet self,
    TDBID slot,
    game.ItemID item
);

void OnItemUnequipped(TDBID slot, game.ItemID item) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "OnItemUnequipped;TweakDBIDItemID",
    (PlayerPuppet_OnItemUnequipped x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnItemUnequipped(
    PlayerPuppet self,
    TDBID slot,
    game.ItemID item
);

bool OnLeftHandCyberwareStateChange(int newState) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnLeftHandCyberwareStateChange(
    PlayerPuppet self,
    int newState
);

bool OnVisionStateChange(int newState) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnVisionStateChange(
    PlayerPuppet self,
    int newState
);

bool OnMeleeWeaponStateChange(int newState) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnMeleeWeaponStateChange(
    PlayerPuppet self,
    int newState
);

bool OnBodySlamStateChange(bool newState) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnBodySlamStateChange(
    PlayerPuppet self,
    bool newState
);

bool OnUpperBodyStateChange(int newState) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnUpperBodyStateChange(
    PlayerPuppet self,
    int newState
);

bool OnCombatGadgetStateChange(int newState) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnCombatGadgetStateChange(
    PlayerPuppet self,
    int newState
);

bool OnSceneTierChange(int newState) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnSceneTierChange(
    PlayerPuppet self,
    int newState
);

bool OnPlayerTakedownStateChange(int takedownState) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnPlayerTakedownStateChange(
    PlayerPuppet self,
    int takedownState
);

void OnEnterAimState() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "OnEnterAimState;",
    (PlayerPuppet_OnEnterAimState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnEnterAimState(
    PlayerPuppet self
);

bool OnVehicleStateChange(int newState) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnVehicleStateChange(
    PlayerPuppet self,
    int newState
);

void HandleDoorsForCombat(WeakHandle<vehicle.BaseObject> vehicle) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "HandleDoorsForCombat;VehicleObject",
    (PlayerPuppet_HandleDoorsForCombat x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_HandleDoorsForCombat(
    PlayerPuppet self,
    WeakHandle<vehicle.BaseObject> vehicle
);

bool OnDriverCombatCameraChange(bool inTPP) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnDriverCombatCameraChange(
    PlayerPuppet self,
    bool inTPP
);

bool OnDriverCombatWeaponTypeChange(int newWeaponType) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnDriverCombatWeaponTypeChange(
    PlayerPuppet self,
    int newWeaponType
);

bool OnWeaponStateChange(int newState) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnWeaponStateChange(
    PlayerPuppet self,
    int newState
);

bool OnControllingDeviceChange(ent.EntityID controllingId) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnControllingDeviceChange(
    PlayerPuppet self,
    ent.EntityID controllingId
);

bool OnNumberOfCombatantsChanged(uint value) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnNumberOfCombatantsChanged(
    PlayerPuppet self,
    uint value
);

void ApplyNoMovementStatGroupModifiers() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "ApplyNoMovementStatGroupModifiers;",
    (PlayerPuppet_ApplyNoMovementStatGroupModifiers x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ApplyNoMovementStatGroupModifiers(
    PlayerPuppet self
);

bool OnPlayerCoverStatusChangedEvent(game.PlayerCoverStatusChangedEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnPlayerCoverStatusChangedEvent(
    PlayerPuppet self,
    game.PlayerCoverStatusChangedEvent? evt
);

bool OnStatusEffectApplied(game.events.ApplyStatusEffectEvent evt) overrideRTTI

Generated hook

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

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

void DisableScanningFromInput() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "DisableScanningFromInput;",
    (PlayerPuppet_DisableScanningFromInput x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_DisableScanningFromInput(
    PlayerPuppet self
);

void SetCustomFastForwardEnabled(bool enabled) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "SetCustomFastForwardEnabled;Bool",
    (PlayerPuppet_SetCustomFastForwardEnabled x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SetCustomFastForwardEnabled(
    PlayerPuppet self,
    bool enabled
);

void SetStatPoolEnabled(game.data.StatPoolType statpool, game.StatPoolModificationTypes statpooltype, bool enabled) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "SetStatPoolEnabled;gamedataStatPoolTypegameStatPoolModificationTypesBool",
    (PlayerPuppet_SetStatPoolEnabled x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SetStatPoolEnabled(
    PlayerPuppet self,
    game.data.StatPoolType statpool,
    game.StatPoolModificationTypes statpooltype,
    bool enabled
);

game.ItemID GetEquippedItemIdInArea(game.data.EquipmentArea equipArea, int? slot) RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetEquippedItemIdInArea;gamedataEquipmentAreaInt32",
    (PlayerPuppet_GetEquippedItemIdInArea x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetEquippedItemIdInArea(
    PlayerPuppet self,
    game.data.EquipmentArea equipArea,
    int? slot
);

void DisableFootstepAudio(bool b) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "DisableFootstepAudio;Bool",
    (PlayerPuppet_DisableFootstepAudio x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void DisableCameraBobbing(bool b) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "DisableCameraBobbing;Bool",
    (PlayerPuppet_DisableCameraBobbing x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void OnAdditiveCameraMovementsSettingChanged() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "OnAdditiveCameraMovementsSettingChanged;",
    (PlayerPuppet_OnAdditiveCameraMovementsSettingChanged x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnAdditiveCameraMovementsSettingChanged(
    PlayerPuppet self
);

void ProcessBreathingEffectApplication(game.events.StatusEffectEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "ProcessBreathingEffectApplication;StatusEffectEvent",
    (PlayerPuppet_ProcessBreathingEffectApplication x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ProcessBreathingEffectApplication(
    PlayerPuppet self,
    game.events.StatusEffectEvent? evt
);

void ProcessTieredDrunkEffect(game.events.StatusEffectEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "ProcessTieredDrunkEffect;StatusEffectEvent",
    (PlayerPuppet_ProcessTieredDrunkEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ProcessTieredDrunkEffect(
    PlayerPuppet self,
    game.events.StatusEffectEvent? evt
);

void ProcessTieredDruggedEffect(game.events.StatusEffectEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "ProcessTieredDruggedEffect;StatusEffectEvent",
    (PlayerPuppet_ProcessTieredDruggedEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ProcessTieredDruggedEffect(
    PlayerPuppet self,
    game.events.StatusEffectEvent? evt
);

void OnStatusEffectUsedHealingItemOrCyberwareApplied() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "OnStatusEffectUsedHealingItemOrCyberwareApplied;",
    (PlayerPuppet_OnStatusEffectUsedHealingItemOrCyberwareApplied x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnStatusEffectUsedHealingItemOrCyberwareApplied(
    PlayerPuppet self
);

bool OnNewPerkSold(NewPerkSoldEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnNewPerkSold(
    PlayerPuppet self,
    NewPerkSoldEvent? evt
);

bool OnStatusEffectRemoved(game.events.RemoveStatusEffect evt) overrideRTTI

Generated hook

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

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

bool OnUpdateEquippedWeaponsHandling(UpdateEquippedWeaponsHandlingEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnUpdateEquippedWeaponsHandling(
    PlayerPuppet self,
    UpdateEquippedWeaponsHandlingEvent? evt
);

void RegisterFriendlyDeviceHostileToEnemies(ent.EntityID deviceID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "RegisterFriendlyDeviceHostileToEnemies;EntityID",
    (PlayerPuppet_RegisterFriendlyDeviceHostileToEnemies x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_RegisterFriendlyDeviceHostileToEnemies(
    PlayerPuppet self,
    ent.EntityID deviceID
);

void UnregisterFriendlyDeviceHostileToEnemies(ent.EntityID deviceID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UnregisterFriendlyDeviceHostileToEnemies;EntityID",
    (PlayerPuppet_UnregisterFriendlyDeviceHostileToEnemies x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_UnregisterFriendlyDeviceHostileToEnemies(
    PlayerPuppet self,
    ent.EntityID deviceID
);

bool OnAttitudeChanged(game.events.AttitudeChangedEvent evt) overrideRTTI

Generated hook

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

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

bool OnAdHocAnimationRequest(AdHocAnimationEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnAdHocAnimationRequest(
    PlayerPuppet self,
    AdHocAnimationEvent? evt
);

bool OnSceneForceWeaponAimEvent(SceneForceWeaponAim evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnSceneForceWeaponAimEvent(
    PlayerPuppet self,
    SceneForceWeaponAim? evt
);

bool OnFelledEvent(FelledEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnFelledEvent(
    PlayerPuppet self,
    FelledEvent? evt
);

bool OnClearAnimFeatureCarryEvent(ClearAnimFeatureCarryEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnClearAnimFeatureCarryEvent(
    PlayerPuppet self,
    ClearAnimFeatureCarryEvent? evt
);

bool OnSceneForceWeaponSafeEvent(SceneForceWeaponSafe evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnSceneForceWeaponSafeEvent(
    PlayerPuppet self,
    SceneForceWeaponSafe? evt
);

bool OnSceneFirstEquipState(SceneFirstEquipState evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnSceneFirstEquipState(
    PlayerPuppet self,
    SceneFirstEquipState? evt
);

bool OnEnableBraindanceActions(EnableBraindanceActions evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnEnableBraindanceActions(
    PlayerPuppet self,
    EnableBraindanceActions? evt
);

bool OnDisableBraindanceActions(DisableBraindanceActions evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnDisableBraindanceActions(
    PlayerPuppet self,
    DisableBraindanceActions? evt
);

bool OnForceBraindanceCameraToggle(ForceBraindanceCameraToggle evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnForceBraindanceCameraToggle(
    PlayerPuppet self,
    ForceBraindanceCameraToggle? evt
);

bool OnPauseBraindance(PauseBraindance evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnPauseBraindance(
    PlayerPuppet self,
    PauseBraindance? evt
);

bool OnModifyOverlappedSecurityArease(ModifyOverlappedSecurityAreas evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnModifyOverlappedSecurityArease(
    PlayerPuppet self,
    ModifyOverlappedSecurityAreas? evt
);

void AddOverrlappedSecurityZone(game.PersistentID zone) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "AddOverrlappedSecurityZone;PersistentID",
    (PlayerPuppet_AddOverrlappedSecurityZone x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_AddOverrlappedSecurityZone(
    PlayerPuppet self,
    game.PersistentID zone
);

void RemoveOverrlappedSecurityZone(game.PersistentID zone) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "RemoveOverrlappedSecurityZone;PersistentID",
    (PlayerPuppet_RemoveOverrlappedSecurityZone x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_RemoveOverrlappedSecurityZone(
    PlayerPuppet self,
    game.PersistentID zone
);

void SendSceneOverridesAnimFeature(game.IBlackboard sceneOverridesBlackboard) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "SendSceneOverridesAnimFeature;IBlackboard",
    (PlayerPuppet_SendSceneOverridesAnimFeature x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SendSceneOverridesAnimFeature(
    PlayerPuppet self,
    game.IBlackboard? sceneOverridesBlackboard
);

bool OnWorkspotStartedEvent(work.WorkspotStartedEvent evt) overrideRTTI

Generated hook

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

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

bool OnWorkspotFinishedEvent(work.WorkspotFinishedEvent evt) overrideRTTI

Generated hook

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

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

CName[] GetPlayerCurrentWorkspotTags() RTTI

bool PlayerContainsWorkspotTag(CName tag) RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "PlayerContainsWorkspotTag;CName",
    (PlayerPuppet_PlayerContainsWorkspotTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool IsCooldownForActionActive(TDBID actionID) RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "IsCooldownForActionActive;TweakDBID",
    (PlayerPuppet_IsCooldownForActionActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsCooldownForActionActive(
    PlayerPuppet self,
    TDBID actionID
);

FactCallbackData CreateFactCallbackData(CName factName) RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "CreateFactCallbackData;CName",
    (PlayerPuppet_CreateFactCallbackData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.FactCallbackData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_CreateFactCallbackData(
    PlayerPuppet self,
    CName factName
);

void RegisterToFacts() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "RegisterToFacts;",
    (PlayerPuppet_RegisterToFacts x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_RegisterToFacts(
    PlayerPuppet self
);

void UnregisterToFacts() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UnregisterToFacts;",
    (PlayerPuppet_UnregisterToFacts x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_UnregisterToFacts(
    PlayerPuppet self
);

bool OnFactChangedEvent(game.FactChangedEvent evt) RTTI

Generated hook

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

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

bool OnSysDebuggerEvent(SysDebuggerEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnSysDebuggerEvent(
    PlayerPuppet self,
    SysDebuggerEvent? evt
);

void AllowOuterwearClothing() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "AllowOuterwearClothing;",
    (PlayerPuppet_AllowOuterwearClothing x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_AllowOuterwearClothing(
    PlayerPuppet self
);

void DisallowOuterwearClothing() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "DisallowOuterwearClothing;",
    (PlayerPuppet_DisallowOuterwearClothing x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_DisallowOuterwearClothing(
    PlayerPuppet self
);

void InitializeFocusModeTagging() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "InitializeFocusModeTagging;",
    (PlayerPuppet_InitializeFocusModeTagging x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_InitializeFocusModeTagging(
    PlayerPuppet self
);

void UnInitializeFocusModeTagging() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UnInitializeFocusModeTagging;",
    (PlayerPuppet_UnInitializeFocusModeTagging x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_UnInitializeFocusModeTagging(
    PlayerPuppet self
);

bool OnRequestEquipHeavyWeapon(RequestEquipHeavyWeapon evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnRequestEquipHeavyWeapon(
    PlayerPuppet self,
    RequestEquipHeavyWeapon? evt
);

bool OnFillAnimWrapperInfoBasedOnEquippedItem(FillAnimWrapperInfoBasedOnEquippedItem evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnFillAnimWrapperInfoBasedOnEquippedItem(
    PlayerPuppet self,
    FillAnimWrapperInfoBasedOnEquippedItem? evt
);

void OnIncapacitated() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnIncapacitated(
    PlayerPuppet self
);

void RefreshCPOVisionAppearance() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "RefreshCPOVisionAppearance;",
    (PlayerPuppet_RefreshCPOVisionAppearance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_RefreshCPOVisionAppearance(
    PlayerPuppet self
);

void OnResurrected() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnResurrected(
    PlayerPuppet self
);

bool IsIncapacitated() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsIncapacitated(
    PlayerPuppet self
);

void RegisterCPOMissionDataCallback() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "RegisterCPOMissionDataCallback;",
    (PlayerPuppet_RegisterCPOMissionDataCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_RegisterCPOMissionDataCallback(
    PlayerPuppet self
);

void UnregisterCPOMissionDataCallback() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UnregisterCPOMissionDataCallback;",
    (PlayerPuppet_UnregisterCPOMissionDataCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_UnregisterCPOMissionDataCallback(
    PlayerPuppet self
);

bool OnCPOMissionDataTransferred(CPOMissionDataTransferred evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnCPOMissionDataTransferred(
    PlayerPuppet self,
    CPOMissionDataTransferred? evt
);

void OnCPOMissionDataTransferredServer(CPOMissionDataTransferred evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "OnCPOMissionDataTransferredServer;CPOMissionDataTransferred",
    (PlayerPuppet_OnCPOMissionDataTransferredServer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnCPOMissionDataTransferredServer(
    PlayerPuppet self,
    CPOMissionDataTransferred? evt
);

void OnCPOMissionDataTransferredClient(CPOMissionDataTransferred evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "OnCPOMissionDataTransferredClient;CPOMissionDataTransferred",
    (PlayerPuppet_OnCPOMissionDataTransferredClient x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnCPOMissionDataTransferredClient(
    PlayerPuppet self,
    CPOMissionDataTransferred? evt
);

void OnCPOMissionDataTransferredChoiceTokenClient(CPOMissionDataTransferred evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "OnCPOMissionDataTransferredChoiceTokenClient;CPOMissionDataTransferred",
    (PlayerPuppet_OnCPOMissionDataTransferredChoiceTokenClient x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnCPOMissionDataTransferredChoiceTokenClient(
    PlayerPuppet self,
    CPOMissionDataTransferred? evt
);

bool OnCPOChoiceTokenDrawTextEvent(CPOChoiceTokenDrawTextEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnCPOChoiceTokenDrawTextEvent(
    PlayerPuppet self,
    CPOChoiceTokenDrawTextEvent? evt
);

void CPOMissionDataOnPlayerDetach() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "CPOMissionDataOnPlayerDetach;",
    (PlayerPuppet_CPOMissionDataOnPlayerDetach x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_CPOMissionDataOnPlayerDetach(
    PlayerPuppet self
);

bool OnCPOMissionPlayerVotedEvent(CPOMissionPlayerVotedEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnCPOMissionPlayerVotedEvent(
    PlayerPuppet self,
    CPOMissionPlayerVotedEvent? evt
);

bool OnPlayerDamageFromDataEvent(PlayerDamageFromDataEvent e) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnPlayerDamageFromDataEvent(
    PlayerPuppet self,
    PlayerDamageFromDataEvent? e
);

bool OnCPOMissionDataUpdateEvent(CPOMissionDataUpdateEvent e) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnCPOMissionDataUpdateEvent(
    PlayerPuppet self,
    CPOMissionDataUpdateEvent? e
);

CName GetCompatibleCPOMissionDeviceName() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetCompatibleCPOMissionDeviceName;",
    (PlayerPuppet_GetCompatibleCPOMissionDeviceName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetCompatibleCPOMissionDeviceName(
    PlayerPuppet self
);

bool OnCPOMissionDataChanged(bool hasData) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnCPOMissionDataChanged(
    PlayerPuppet self,
    bool hasData
);

void SetHasCPOMissionData(bool setHasData, CName damagesPreset, CName compatibleDeviceName, bool ownerDecidesOnTransfer) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "SetHasCPOMissionData;BoolCNameCNameBool",
    (PlayerPuppet_SetHasCPOMissionData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SetHasCPOMissionData(
    PlayerPuppet self,
    bool setHasData,
    CName damagesPreset,
    CName compatibleDeviceName,
    bool ownerDecidesOnTransfer
);

bool OnCPOGiveChoiceTokenEvent(quest.MultiplayerGiveChoiceTokenEvent e) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnCPOGiveChoiceTokenEvent(
    PlayerPuppet self,
    quest.MultiplayerGiveChoiceTokenEvent? e
);

void ProcessDamageEvents(bool addDamage, CName damagesPreset) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "ProcessDamageEvents;BoolCName",
    (PlayerPuppet_ProcessDamageEvents x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ProcessDamageEvents(
    PlayerPuppet self,
    bool addDamage,
    CName damagesPreset
);

bool OnDeath(game.events.DeathEvent evt) overrideRTTI

Generated hook

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

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

void ForceCloseRadialWheel() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "ForceCloseRadialWheel;",
    (PlayerPuppet_ForceCloseRadialWheel x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ForceCloseRadialWheel(
    PlayerPuppet self
);

void Revive(float percAmount) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "Revive;Float",
    (PlayerPuppet_Revive x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_Revive(
    PlayerPuppet self,
    float percAmount
);

bool OnTargetNeutraliziedEvent(TargetNeutraliziedEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnTargetNeutraliziedEvent(
    PlayerPuppet self,
    TargetNeutraliziedEvent? evt
);

bool OnRewindableSectionEvent(scn.RewindableSectionEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnRewindableSectionEvent(
    PlayerPuppet self,
    scn.RewindableSectionEvent? evt
);

bool IsInCombat() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsInCombat(
    PlayerPuppet self
);

bool IsNaked() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsNaked(
    PlayerPuppet self
);

bool IsMoving() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsMoving(
    PlayerPuppet self
);

bool IsMovingHorizontally() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsMovingHorizontally(
    PlayerPuppet self
);

bool IsMovingVertically() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsMovingVertically(
    PlayerPuppet self
);

void SetWarningMessage(string message, game.SimpleMessageType? msgType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "SetWarningMessage;script_ref<String>SimpleMessageType",
    (PlayerPuppet_SetWarningMessage x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SetWarningMessage(
    PlayerPuppet self,
    string message,
    game.SimpleMessageType? msgType
);

void StartProcessingVForVendettaAchievement(game.Object deathInstigator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "StartProcessingVForVendettaAchievement;GameObject",
    (PlayerPuppet_StartProcessingVForVendettaAchievement x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_StartProcessingVForVendettaAchievement(
    PlayerPuppet self,
    game.Object? deathInstigator
);

void CreateVendettaTimeDelayEvent() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "CreateVendettaTimeDelayEvent;",
    (PlayerPuppet_CreateVendettaTimeDelayEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_CreateVendettaTimeDelayEvent(
    PlayerPuppet self
);

bool OnFinishedVendettaTimeEvent(FinishedVendettaTimeEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnFinishedVendettaTimeEvent(
    PlayerPuppet self,
    FinishedVendettaTimeEvent? evt
);

void CheckVForVendettaAchievement(TargetNeutraliziedEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "CheckVForVendettaAchievement;TargetNeutraliziedEvent",
    (PlayerPuppet_CheckVForVendettaAchievement x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_CheckVForVendettaAchievement(
    PlayerPuppet self,
    TargetNeutraliziedEvent? evt
);

bool OnProcessVendettaAchievementEvent(ProcessVendettaAchievementEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnProcessVendettaAchievementEvent(
    PlayerPuppet self,
    ProcessVendettaAchievementEvent? evt
);

CName GetNetworkLinkSlotName() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetNetworkLinkSlotName(
    PlayerPuppet self
);

bool IsNetworkLinkDynamic() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsNetworkLinkDynamic(
    PlayerPuppet self
);

void RegisterRemoteMappin() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "RegisterRemoteMappin;",
    (PlayerPuppet_RegisterRemoteMappin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_RegisterRemoteMappin(
    PlayerPuppet self
);

void UnregisterRemoteMappin() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UnregisterRemoteMappin;",
    (PlayerPuppet_UnregisterRemoteMappin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_UnregisterRemoteMappin(
    PlayerPuppet self
);

bool OnRegisterFastTravelPoints(RegisterFastTravelPointsEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnRegisterFastTravelPoints(
    PlayerPuppet self,
    RegisterFastTravelPointsEvent? evt
);

bool ShouldShowScanner() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ShouldShowScanner(
    PlayerPuppet self
);

bool OnWoundedInstigated(WoundedInstigated evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnWoundedInstigated(
    PlayerPuppet self,
    WoundedInstigated? evt
);

bool OnDismembermentInstigated(DismembermentInstigated evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnDismembermentInstigated(
    PlayerPuppet self,
    DismembermentInstigated? evt
);

void ToggleFocusedGrenadeShootingPerk(bool activate) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "ToggleFocusedGrenadeShootingPerk;Bool",
    (PlayerPuppet_ToggleFocusedGrenadeShootingPerk x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ToggleFocusedGrenadeShootingPerk(
    PlayerPuppet self,
    bool activate
);

game.TargetingComponent? GetPrimaryTargetingComponent() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetPrimaryTargetingComponent;",
    (PlayerPuppet_GetPrimaryTargetingComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TargetingComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetPrimaryTargetingComponent(
    PlayerPuppet self
);

game.BreachFinderComponent? GetBreachFinderComponent() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetBreachFinderComponent;",
    (PlayerPuppet_GetBreachFinderComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.BreachFinderComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetBreachFinderComponent(
    PlayerPuppet self
);

void ApplyNPCLevelAndProgressionBuild(WeakHandle<game.Object> npc, CName actionName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "ApplyNPCLevelAndProgressionBuild;GameObjectCName",
    (PlayerPuppet_ApplyNPCLevelAndProgressionBuild x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ApplyNPCLevelAndProgressionBuild(
    PlayerPuppet self,
    WeakHandle<game.Object> npc,
    CName actionName
);

bool OnMeleeHitEvent(MeleeHitEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnMeleeHitEvent(
    PlayerPuppet self,
    MeleeHitEvent? evt
);

bool OnMeleeHitSloMo(MeleeHitSlowMoEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnMeleeHitSloMo(
    PlayerPuppet self,
    MeleeHitSlowMoEvent? evt
);

int FindBuildSpacing(string enumType, string buildNameStringPart) RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "FindBuildSpacing;script_ref<String>script_ref<String>",
    (PlayerPuppet_FindBuildSpacing x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_FindBuildSpacing(
    PlayerPuppet self,
    string enumType,
    string buildNameStringPart
);

void GotKeycardNotification() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "GotKeycardNotification;",
    (PlayerPuppet_GotKeycardNotification x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GotKeycardNotification(
    PlayerPuppet self
);

bool OnHackTargetEvent(HackTargetEvent evt) overrideRTTI

Generated hook

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

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

bool OnCarHitPlayer(game.OnCarHitPlayer evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnCarHitPlayer(
    PlayerPuppet self,
    game.OnCarHitPlayer? evt
);

bool OnDistrictChanged(PlayerEnteredNewDistrictEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnDistrictChanged(
    PlayerPuppet self,
    PlayerEnteredNewDistrictEvent? evt
);

float GetGunshotRange() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetGunshotRange;",
    (PlayerPuppet_GetGunshotRange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetGunshotRange(
    PlayerPuppet self
);

float GetExplosionRange() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetExplosionRange;",
    (PlayerPuppet_GetExplosionRange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetExplosionRange(
    PlayerPuppet self
);

game.ui.MinigameProgramData[] GetMinigamePrograms() RTTI

bool OnUpdateMiniGameProgramsEvent(UpdateMiniGameProgramsEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnUpdateMiniGameProgramsEvent(
    PlayerPuppet self,
    UpdateMiniGameProgramsEvent? evt
);

void UpdateMinigamePrograms(game.ui.MinigameProgramData program, bool add) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UpdateMinigamePrograms;MinigameProgramDataBool",
    (PlayerPuppet_UpdateMinigamePrograms x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_UpdateMinigamePrograms(
    PlayerPuppet self,
    game.ui.MinigameProgramData program,
    bool add
);

void RestoreMinigamePrograms() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "RestoreMinigamePrograms;",
    (PlayerPuppet_RestoreMinigamePrograms x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_RestoreMinigamePrograms(
    PlayerPuppet self
);

game.IBlackboard? GetMinigameBlackboard() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetMinigameBlackboard;",
    (PlayerPuppet_GetMinigameBlackboard x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IBlackboard>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetMinigameBlackboard(
    PlayerPuppet self
);

void InitInterestingFacts() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "InitInterestingFacts;",
    (PlayerPuppet_InitInterestingFacts x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_InitInterestingFacts(
    PlayerPuppet self
);

void UpdateAimAssist() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UpdateAimAssist;",
    (PlayerPuppet_UpdateAimAssist x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_UpdateAimAssist(
    PlayerPuppet self
);

void UpdateAimAssistDelayedTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UpdateAimAssistDelayedTask;ScriptTaskData",
    (PlayerPuppet_UpdateAimAssistDelayedTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void UpdateAimAssistImmediate() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UpdateAimAssistImmediate;",
    (PlayerPuppet_UpdateAimAssistImmediate x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_UpdateAimAssistImmediate(
    PlayerPuppet self
);

EAimAssistLevel GetAimAssistLevel() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetAimAssistLevel;",
    (PlayerPuppet_GetAimAssistLevel x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EAimAssistLevel>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetAimAssistLevel(
    PlayerPuppet self
);

bool IsAimSnapEnabled() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsAimSnapEnabled(
    PlayerPuppet self
);

void ApplyAimAssistSettings(AimAssistSettingConfig config) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "ApplyAimAssistSettings;AimAssistSettingConfig",
    (PlayerPuppet_ApplyAimAssistSettings x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ApplyAimAssistSettings(
    PlayerPuppet self,
    AimAssistSettingConfig config
);

bool ShouldAllowCycleToFistCyberware() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ShouldAllowCycleToFistCyberware(
    PlayerPuppet self
);

void RegisterInterestingFactsListeners() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "RegisterInterestingFactsListeners;",
    (PlayerPuppet_RegisterInterestingFactsListeners x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_RegisterInterestingFactsListeners(
    PlayerPuppet self
);

void UnregisterInterestingFactsListeners() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "UnregisterInterestingFactsListeners;",
    (PlayerPuppet_UnregisterInterestingFactsListeners x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_UnregisterInterestingFactsListeners(
    PlayerPuppet self
);

void SetBlackboardIntVariable(game.bb.ScriptID_Int32 id, int value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "SetBlackboardIntVariable;BlackboardID_IntInt32",
    (PlayerPuppet_SetBlackboardIntVariable x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SetBlackboardIntVariable(
    PlayerPuppet self,
    game.bb.ScriptID_Int32 id,
    int value
);

void InvalidateZone() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "InvalidateZone;",
    (PlayerPuppet_InvalidateZone x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_InvalidateZone(
    PlayerPuppet self
);

float GetStaminaValueUnsafe() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetStaminaValueUnsafe;",
    (PlayerPuppet_GetStaminaValueUnsafe x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetStaminaValueUnsafe(
    PlayerPuppet self
);

float GetStaminaPercUnsafe() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetStaminaPercUnsafe;",
    (PlayerPuppet_GetStaminaPercUnsafe x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetStaminaPercUnsafe(
    PlayerPuppet self
);

bool IsExhausted() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsExhausted(
    PlayerPuppet self
);

int GetHealingItemCharges() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetHealingItemCharges;",
    (PlayerPuppet_GetHealingItemCharges x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetHealingItemCharges(
    PlayerPuppet self
);

int GetHealingItemUseCost() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetHealingItemUseCost;",
    (PlayerPuppet_GetHealingItemUseCost x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetHealingItemUseCost(
    PlayerPuppet self
);

bool HealingItemChargesAreOnMax() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_HealingItemChargesAreOnMax(
    PlayerPuppet self
);

int GetGrenadeCharges() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetGrenadeCharges;",
    (PlayerPuppet_GetGrenadeCharges x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetGrenadeCharges(
    PlayerPuppet self
);

int GetGrenadeCharges(game.data.Grenade_Record item) RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetGrenadeCharges;Grenade_Record",
    (PlayerPuppet_GetGrenadeCharges2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetGrenadeCharges2(
    PlayerPuppet self,
    game.data.Grenade_Record? item
);

bool GrenadeChargesAreOnMax() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GrenadeChargesAreOnMax(
    PlayerPuppet self
);

int GetGrenadeThrowCost() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetGrenadeThrowCost;",
    (PlayerPuppet_GetGrenadeThrowCost x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetGrenadeThrowCost(
    PlayerPuppet self
);

int GetGrenadeThrowCostClean() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetGrenadeThrowCostClean;",
    (PlayerPuppet_GetGrenadeThrowCostClean x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetGrenadeThrowCostClean(
    PlayerPuppet self
);

int GetProjectileLauncherCharges() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetProjectileLauncherCharges;",
    (PlayerPuppet_GetProjectileLauncherCharges x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetProjectileLauncherCharges(
    PlayerPuppet self
);

int GetProjectileLauncherShootCost() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetProjectileLauncherShootCost;",
    (PlayerPuppet_GetProjectileLauncherShootCost x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetProjectileLauncherShootCost(
    PlayerPuppet self
);

void OnZoneFactChanged(int val) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "OnZoneFactChanged;Int32",
    (PlayerPuppet_OnZoneFactChanged x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnZoneFactChanged(
    PlayerPuppet self,
    int val
);

void SetSecurityAreaTypeE3HACK(ESecurityAreaType securityAreaType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "SetSecurityAreaTypeE3HACK;ESecurityAreaType",
    (PlayerPuppet_SetSecurityAreaTypeE3HACK x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SetSecurityAreaTypeE3HACK(
    PlayerPuppet self,
    ESecurityAreaType securityAreaType
);

void OnEnterUndefinedZone() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "OnEnterUndefinedZone;",
    (PlayerPuppet_OnEnterUndefinedZone x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnEnterUndefinedZone(
    PlayerPuppet self
);

void OnEnterPublicZone() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "OnEnterPublicZone;",
    (PlayerPuppet_OnEnterPublicZone x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnEnterPublicZone(
    PlayerPuppet self
);

void OnExitPublicZone() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "OnExitPublicZone;",
    (PlayerPuppet_OnExitPublicZone x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnExitPublicZone(
    PlayerPuppet self
);

void OnEnterSafeZone() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "OnEnterSafeZone;",
    (PlayerPuppet_OnEnterSafeZone x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnEnterSafeZone(
    PlayerPuppet self
);

void OnExitSafeZone() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "OnExitSafeZone;",
    (PlayerPuppet_OnExitSafeZone x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnExitSafeZone(
    PlayerPuppet self
);

void OnEnterRestrictedZone() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "OnEnterRestrictedZone;",
    (PlayerPuppet_OnEnterRestrictedZone x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnEnterRestrictedZone(
    PlayerPuppet self
);

void OnEnterDangerousZone() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "OnEnterDangerousZone;",
    (PlayerPuppet_OnEnterDangerousZone x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnEnterDangerousZone(
    PlayerPuppet self
);

game.CityAreaType GetCurrentZoneType(int factValue) RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetCurrentZoneType;Int32",
    (PlayerPuppet_GetCurrentZoneType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.CityAreaType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetCurrentZoneType(
    PlayerPuppet self,
    int factValue
);

game.CityAreaType GetCurrentSecurityZoneType(game.Object owner) RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetCurrentSecurityZoneType;GameObject",
    (PlayerPuppet_GetCurrentSecurityZoneType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.CityAreaType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetCurrentSecurityZoneType(
    PlayerPuppet self,
    game.Object? owner
);

bool OnInvalidateVisionModeController(PlayerVisionModeControllerInvalidateEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnInvalidateVisionModeController(
    PlayerPuppet self,
    PlayerVisionModeControllerInvalidateEvent? evt
);

bool OnInvalidateCombatController(PlayerCombatControllerInvalidateEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnInvalidateCombatController(
    PlayerPuppet self,
    PlayerCombatControllerInvalidateEvent? evt
);

bool OnStartedBeingTrackedAsHostile(AIStartedBeingTrackedAsHostile evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnStartedBeingTrackedAsHostile(
    PlayerPuppet self,
    AIStartedBeingTrackedAsHostile? evt
);

bool OnStoppedBeingTrackedAsHostile(AIStoppedBeingTrackedAsHostile evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnStoppedBeingTrackedAsHostile(
    PlayerPuppet self,
    AIStoppedBeingTrackedAsHostile? evt
);

bool OnCrouchDelayEvent(CrouchDelayEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnCrouchDelayEvent(
    PlayerPuppet self,
    CrouchDelayEvent? evt
);

PlayerQuickhackData[] GetCachedQuickHackList() RTTI

bool OnDisableVisualOverride(DisableVisualOverride evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnDisableVisualOverride(
    PlayerPuppet self,
    DisableVisualOverride? evt
);

bool OnRestoreVisualOverride(RestoreVisualOverride evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnRestoreVisualOverride(
    PlayerPuppet self,
    RestoreVisualOverride? evt
);

bool OnEnableVisualOverride(EnableVisualOverride evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnEnableVisualOverride(
    PlayerPuppet self,
    EnableVisualOverride? evt
);

EquipmentSystem? GetEquipmentSystem() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetEquipmentSystem;",
    (PlayerPuppet_GetEquipmentSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EquipmentSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetEquipmentSystem(
    PlayerPuppet self
);

bool OnHideVisualSlot(HideVisualSlot evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnHideVisualSlot(
    PlayerPuppet self,
    HideVisualSlot? evt
);

bool OnRestoreVisualSlot(RestoreVisualSlot evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnRestoreVisualSlot(
    PlayerPuppet self,
    RestoreVisualSlot? evt
);

game.data.EquipmentArea GetAreaFromEnum(TransmogSlots slot) RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "GetAreaFromEnum;TransmogSlots",
    (PlayerPuppet_GetAreaFromEnum x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.EquipmentArea>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetAreaFromEnum(
    PlayerPuppet self,
    TransmogSlots slot
);

bool OnRefreshQuickhackMenuEvent(RefreshQuickhackMenuEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnRefreshQuickhackMenuEvent(
    PlayerPuppet self,
    RefreshQuickhackMenuEvent? evt
);

bool OnHalloweenEvent(game.HalloweenEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnHalloweenEvent(
    PlayerPuppet self,
    game.HalloweenEvent? evt
);

bool OnVehicleRadioEvent(VehicleRadioEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnVehicleRadioEvent(
    PlayerPuppet self,
    VehicleRadioEvent? evt
);

bool OnVehicleRadioStationChanged(vehicle.RadioStationChanged evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnVehicleRadioStationChanged(
    PlayerPuppet self,
    vehicle.RadioStationChanged? evt
);

bool OnRadioToggleEvent(RadioToggleEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnRadioToggleEvent(
    PlayerPuppet self,
    RadioToggleEvent? evt
);

bool PSIsInDriverCombat() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_PSIsInDriverCombat(
    PlayerPuppet self
);

void SetPSIsInDriverCombat(bool isInDriverCombat) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "SetPSIsInDriverCombat;Bool",
    (PlayerPuppet_SetPSIsInDriverCombat x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SetPSIsInDriverCombat(
    PlayerPuppet self,
    bool isInDriverCombat
);

int PSGetPocketRadioStation() RTTI

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "PSGetPocketRadioStation;",
    (PlayerPuppet_PSGetPocketRadioStation x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_PSGetPocketRadioStation(
    PlayerPuppet self
);

void PSSetPocketRadioStation(int value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "PSSetPocketRadioStation;Int32",
    (PlayerPuppet_PSSetPocketRadioStation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void OnExplosiveDeviceExploded() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "OnExplosiveDeviceExploded;",
    (PlayerPuppet_OnExplosiveDeviceExploded x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_OnExplosiveDeviceExploded(
    PlayerPuppet self
);

void PromoteOpticalCamoEffectorToCompletelyBlocking() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "PromoteOpticalCamoEffectorToCompletelyBlocking;",
    (PlayerPuppet_PromoteOpticalCamoEffectorToCompletelyBlocking x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_PromoteOpticalCamoEffectorToCompletelyBlocking(
    PlayerPuppet self
);

static float GetQuickMeleeCooldown() staticRTTI global

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "PlayerPuppet::GetQuickMeleeCooldown;",
    (PlayerPuppet_GetQuickMeleeCooldown x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

static bool IsTargetFriendlyNPC(PlayerPuppet player, ent.Entity target) staticRTTI global

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "PlayerPuppet::IsTargetFriendlyNPC;PlayerPuppetEntity",
    (PlayerPuppet_IsTargetFriendlyNPC x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsTargetFriendlyNPC(
    PlayerPuppet? player,
    ent.Entity? target
);

static bool IsSwimming(WeakHandle<PlayerPuppet> player) staticRTTI global

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "PlayerPuppet::IsSwimming;PlayerPuppet",
    (PlayerPuppet_IsSwimming x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsSwimming(
    WeakHandle<PlayerPuppet> player
);

static bool IsJohnnySicknessBreathingEffectActive(WeakHandle<PlayerPuppet> player) staticRTTI global

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "PlayerPuppet::IsJohnnySicknessBreathingEffectActive;PlayerPuppet",
    (PlayerPuppet_IsJohnnySicknessBreathingEffectActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsJohnnySicknessBreathingEffectActive(
    WeakHandle<PlayerPuppet> player
);

static void ChacheQuickHackListCleanup(WeakHandle<game.Object> objectt) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "PlayerPuppet::ChacheQuickHackListCleanup;GameObject",
    (PlayerPuppet_ChacheQuickHackListCleanup x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static float GetLowHealthThreshold() staticRTTI global

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "PlayerPuppet::GetLowHealthThreshold;",
    (PlayerPuppet_GetLowHealthThreshold x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

static game.ItemID[] GetPlayerQuickHackInCyberDeck(WeakHandle<PlayerPuppet> player) staticRTTI global

static game.PSMCombat GetCurrentCombatState(WeakHandle<PlayerPuppet> player) staticRTTI global

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "PlayerPuppet::GetCurrentCombatState;PlayerPuppet",
    (PlayerPuppet_GetCurrentCombatState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.PSMCombat>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetCurrentCombatState(
    WeakHandle<PlayerPuppet> player
);

static game.PSMVehicle GetCurrentVehicleState(WeakHandle<PlayerPuppet> player) staticRTTI global

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "PlayerPuppet::GetCurrentVehicleState;PlayerPuppet",
    (PlayerPuppet_GetCurrentVehicleState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.PSMVehicle>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetCurrentVehicleState(
    WeakHandle<PlayerPuppet> player
);

static void ReevaluateAllBreathingEffects(WeakHandle<PlayerPuppet> player) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "PlayerPuppet::ReevaluateAllBreathingEffects;PlayerPuppet",
    (PlayerPuppet_ReevaluateAllBreathingEffects x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ReevaluateAllBreathingEffects(
    WeakHandle<PlayerPuppet> player
);

static game.PSMHighLevel GetCurrentHighLevelState(WeakHandle<PlayerPuppet> player) staticRTTI global

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "PlayerPuppet::GetCurrentHighLevelState;PlayerPuppet",
    (PlayerPuppet_GetCurrentHighLevelState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.PSMHighLevel>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetCurrentHighLevelState(
    WeakHandle<PlayerPuppet> player
);

static void ChacheQuickHackList(WeakHandle<PlayerPuppet> self, PlayerQuickhackData[] QHList) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "PlayerPuppet::ChacheQuickHackList;PlayerPuppetarray<PlayerQuickhackData>",
    (PlayerPuppet_ChacheQuickHackList x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_ChacheQuickHackList(
    WeakHandle<PlayerPuppet> self,
    PlayerQuickhackData[] QHList
);

static game.PSMLocomotionStates GetCurrentLocomotionState(WeakHandle<PlayerPuppet> player) staticRTTI global

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "PlayerPuppet::GetCurrentLocomotionState;PlayerPuppet",
    (PlayerPuppet_GetCurrentLocomotionState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.PSMLocomotionStates>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetCurrentLocomotionState(
    WeakHandle<PlayerPuppet> player
);

static bool CanApplyBreathingEffect(WeakHandle<PlayerPuppet> player) staticRTTI global

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "PlayerPuppet::CanApplyBreathingEffect;PlayerPuppet",
    (PlayerPuppet_CanApplyBreathingEffect x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_CanApplyBreathingEffect(
    WeakHandle<PlayerPuppet> player
);

static TDBID[] GetPlayerQuickHackInCyberDeckTweakDBID(WeakHandle<PlayerPuppet> player) staticRTTI global

static void SetBuild(ScriptGameInstance inst, string stringType, bool isDebug) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "PlayerPuppet::SetBuild;GameInstancescript_ref<String>Bool",
    (PlayerPuppet_SetBuild x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SetBuild(
    ScriptGameInstance inst,
    string stringType,
    bool isDebug
);

static void RemoveItemGameplayPackage(game.Object objectToRemoveFrom, game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "PlayerPuppet::RemoveItemGameplayPackage;GameObjectItemID",
    (PlayerPuppet_RemoveItemGameplayPackage x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_RemoveItemGameplayPackage(
    game.Object? objectToRemoveFrom,
    game.ItemID itemID
);

static float GetCriticalHealthThreshold() staticRTTI global

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "PlayerPuppet::GetCriticalHealthThreshold;",
    (PlayerPuppet_GetCriticalHealthThreshold x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

static int GetSceneTier(WeakHandle<PlayerPuppet> player) staticRTTI global

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "PlayerPuppet::GetSceneTier;PlayerPuppet",
    (PlayerPuppet_GetSceneTier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_GetSceneTier(
    WeakHandle<PlayerPuppet> player
);

static TDBID[] GetPlayerQuickHackInCyberDeckTweakDBID(WeakHandle<PlayerPuppet> player, game.data.Quality quality) staticRTTI global

static bool IsTargetChildNPC(PlayerPuppet player, ent.Entity target) staticRTTI global

Generated hook

re.Hooks.Place(
    "PlayerPuppet",
    "PlayerPuppet::IsTargetChildNPC;PlayerPuppetEntity",
    (PlayerPuppet_IsTargetChildNPC x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_IsTargetChildNPC(
    PlayerPuppet? player,
    ent.Entity? target
);

static void SetLevel(ScriptGameInstance inst, string stringType, string stringVal, telemetry.LevelGainReason levelGainReason)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "PlayerPuppet::SetLevel;GameInstancescript_ref<String>script_ref<String>telemetryLevelGainReason",
    (PlayerPuppet_SetLevel x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PlayerPuppet_SetLevel(
    ScriptGameInstance inst,
    string stringType,
    string stringVal,
    telemetry.LevelGainReason levelGainReason
);

static void SendOnBeingNoticed(WeakHandle<PlayerPuppet> player, WeakHandle<game.Object> objectThatNoticed) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PlayerPuppet",
    "PlayerPuppet::SendOnBeingNoticed;PlayerPuppetGameObject",
    (PlayerPuppet_SendOnBeingNoticed x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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