class game

Object

game.Object

32 properties
363 functions
73 derived classes

Extends ent.GameEntity ent.Entity IScriptable ISerializable

Derived

AIAdjustableStreamingRangeTarget, BunkerMapObject, CCTVCamera, CPOMissionDevice, Candle, CasinoTableObject, DEBUG_ItemRebalancer, DEBUG_VirtualShopkeeper, DebugInteractionObject, DebugTextDrawer

Show 63 more of 73 derived classes

FakeDoor, FakeFeature, GravityChangeTrigger, InspectDummy, InspectionObject, JumpPod, Master_Test, MovableQuestTrigger, NcartStationMarker, PSD_Trigger, SampleDeviceClass, SampleEntityWithCounter, SampleInteractiveEntityThatBumpsTheCounter, SceneScreen, Slave_Test, VirtualItem_TEMP, WireRepairable, cp.Conveyor, cp.ConveyorObject, cp.MeatBag, cp.PlayerDetector, cp.PlayerDetector_PseudoDevice, cp.StairsTrigger, cp.TestPhysXDynamicMovement, cp.TestPlatformController, cp.TimerTest, dbg.Spawner, game.AreaVolume, game.AudioClueObject, game.AugmentedRealitySign, game.Controller, game.CoverObject, game.CpoArmouryItem, game.CpoPickableItem, game.DebugFreeCamera, game.DestructibleObject, game.DeviceBase, game.FreeCamera, game.LadderObject, game.LootBag, game.LootContainerBase, game.LootObject, game.NetrunnerPrototypeNetworkNode, game.PhotoModeCameraObject, game.PhotomodeLightObject, game.PickupObject, game.Remains, game.TimeDilatable, game.WeakspotObject, game.ui.CasinoChips, game.ui.CyberspaceUIObject, game.ui.EntityPreviewGameObject, game.ui.WorldMapGameObject, gen.LevelRandomizer, mp.PersistentTestBox, muliplayer.InteractionTest, sample.VisClueMaster, sample.VisClueSlave, sample.VisWireMaster, sample.VisWireMasterTwo, sample.VisWireSlave, sample.VisWireSlaveTwo, vehicle.BaseObject

Properties

Property	Type	Offset
`persistentState`	`game.PersistentState?`	`0x168`
`playerSocket`	`game.PlayerSocket`	`0x1D0`
`uiSlotComponent`	`ent.SlotComponent?`	`0x218`
`tags`	`red.TagList`	`0x230`
`audioResourceName`	`CName`	`0x1C8`
`visibilityCheckDistance`	`float`	`0x1F8`
`forceRegisterInHudManager`	`bool`	`0x0`	scripted
`prereqListeners`	`GameObjectListener?[]`	`0x8`	scripted
`statusEffectListeners`	`StatusEffectTriggerListener?[]`	`0x18`	scripted
`lastEngineTime`	`float`	`0x28`	scripted
`accumulatedTimePasssed`	`float`	`0x2C`	scripted
`scanningComponent`	`game.ScanningComponent?`	`0x30`	scripted
`visionComponent`	`game.VisionModeComponent?`	`0x40`	scripted
`isHighlightedInFocusMode`	`bool`	`0x50`	scripted
`statusEffectComponent`	`game.StatusEffectComponent?`	`0x58`	scripted
`markAsQuest`	`bool`	`0x68`	scripted
`e3ObjectRevealed`	`bool`	`0x69`	scripted
`workspotMapper`	`WorkspotMapperComponent?`	`0x70`	scripted
`stimBroadcaster`	`StimBroadcasterComponent?`	`0x80`	scripted
`squadMemberComponent`	`SquadMemberBaseComponent?`	`0x90`	scripted
`sourceShootComponent`	`game.SourceShootComponent?`	`0xA0`	scripted
`targetShootComponent`	`game.TargetShootComponent?`	`0xB0`	scripted
`receivedDamageHistory`	`DamageHistoryEntry[]`	`0xC0`	scripted
`forceDefeatReward`	`bool`	`0xD0`	scripted
`killRewardDisabled`	`bool`	`0xD1`	scripted
`willDieSoon`	`bool`	`0xD2`	scripted
`isScannerDataDirty`	`bool`	`0xD3`	scripted
`hasVisibilityForcedInAnimSystem`	`bool`	`0xD4`	scripted
`isDead`	`bool`	`0xD5`	scripted
`lastHitInstigatorID`	`ent.EntityID`	`0xD8`	scripted
`hitInstigatorCooldownID`	`game.DelayID`	`0xE0`	scripted
`isTargetedWithSmartWeapon`	`bool`	`0xE8`	scripted

Functions

CName GetName() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetName",
    (Object_GetName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetName(
    game.Object self
);

void GetAudioName() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "GetAudioName",
    (Object_GetAudioName x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetAudioName(
    game.Object self
);

string GetDisplayName() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetDisplayName",
    (Object_GetDisplayName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetDisplayName(
    game.Object self
);

string GetDisplayDescription() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetDisplayDescription",
    (Object_GetDisplayDescription x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetDisplayDescription(
    game.Object self
);

ScriptGameInstance GetGame() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_GetGame(
    game.Object self
);

void EnableTransformUpdates(bool enable) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "EnableTransformUpdates",
    (Object_EnableTransformUpdates x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_EnableTransformUpdates(
    game.Object self,
    bool enable
);

bool IsSelectedForDebugging() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsSelectedForDebugging",
    (Object_IsSelectedForDebugging x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsSelectedForDebugging(
    game.Object self
);

bool IsPlayerControlled() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsPlayerControlled",
    (Object_IsPlayerControlled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsPlayerControlled(
    game.Object self
);

WeakHandle<game.Object> GetOwner() RTTI

string GetTracedActionName() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetTracedActionName",
    (Object_GetTracedActionName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetTracedActionName(
    game.Object self
);

void RegisterInputListener(IScriptable listener, CName? name) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "RegisterInputListener",
    (Object_RegisterInputListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_RegisterInputListener(
    game.Object self,
    IScriptable? listener,
    CName? name
);

void RegisterInputListenerWithOwner(IScriptable listener, CName name) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "RegisterInputListenerWithOwner",
    (Object_RegisterInputListenerWithOwner x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_RegisterInputListenerWithOwner(
    game.Object self,
    IScriptable? listener,
    CName name
);

void UnregisterInputListener(IScriptable listener, CName? name) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "UnregisterInputListener",
    (Object_UnregisterInputListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_UnregisterInputListener(
    game.Object self,
    IScriptable? listener,
    CName? name
);

void GetCurveValue(out float x, out float y, CName curveName, bool isDebug) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "GetCurveValue",
    (Object_GetCurveValue x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetCurveValue(
    game.Object self,
    float x,
    float y,
    CName curveName,
    bool isDebug
);

CName GetCurrentContext() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetCurrentContext",
    (Object_GetCurrentContext x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetCurrentContext(
    game.Object self
);

bool PlayerLastUsedPS5Pad() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "PlayerLastUsedPS5Pad",
    (Object_PlayerLastUsedPS5Pad x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_PlayerLastUsedPS5Pad(
    game.Object self
);

bool PlayerLastUsedPad() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "PlayerLastUsedPad",
    (Object_PlayerLastUsedPad x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_PlayerLastUsedPad(
    game.Object self
);

bool PlayerLastUsedKBM() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "PlayerLastUsedKBM",
    (Object_PlayerLastUsedKBM x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_PlayerLastUsedKBM(
    game.Object self
);

bool TriggerEvent(CName eventName, IScriptable? data, int? flags) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "TriggerEvent",
    (Object_TriggerEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_TriggerEvent(
    game.Object self,
    CName eventName,
    IScriptable? data,
    int? flags
);

game.ObjectPS? GetPS() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetPS",
    (Object_GetPS x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ObjectPS>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetPS(
    game.Object self
);

game.ObjectPS? GetBasePS() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetBasePS",
    (Object_GetBasePS x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ObjectPS>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetBasePS(
    game.Object self
);

bool HasTag(CName tag) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "HasTag",
    (Object_HasTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasTag(
    game.Object self,
    CName tag
);

void ReplicateAnimFeature(game.Object obj, CName inputName, anim.AnimFeature value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "ReplicateAnimFeature",
    (Object_ReplicateAnimFeature x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ReplicateAnimFeature(
    game.Object self,
    game.Object? obj,
    CName inputName,
    anim.AnimFeature? value
);

void ReplicateAnimEvent(game.Object obj, CName eventName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "ReplicateAnimEvent",
    (Object_ReplicateAnimEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ReplicateAnimEvent(
    game.Object self,
    game.Object? obj,
    CName eventName
);

void QueueReplicatedEvent(red.Event evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "QueueReplicatedEvent",
    (Object_QueueReplicatedEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_QueueReplicatedEvent(
    game.Object self,
    red.Event? evt
);

void ReplicateInputFloat(game.Object obj, CName inputName, float value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "ReplicateInputFloat",
    (Object_ReplicateInputFloat x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ReplicateInputFloat(
    game.Object self,
    game.Object? obj,
    CName inputName,
    float value
);

void ReplicateInputBool(game.Object obj, CName inputName, bool value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "ReplicateInputBool",
    (Object_ReplicateInputBool x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void ReplicateInputInt(game.Object obj, CName inputName, int value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "ReplicateInputInt",
    (Object_ReplicateInputInt x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ReplicateInputInt(
    game.Object self,
    game.Object? obj,
    CName inputName,
    int value
);

void ReplicateInputVector(game.Object obj, CName inputName, Vector4 value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "ReplicateInputVector",
    (Object_ReplicateInputVector x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ReplicateInputVector(
    game.Object self,
    game.Object? obj,
    CName inputName,
    Vector4 value
);

ent.SlotComponent? GetUISlotComponent() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetUISlotComponent",
    (Object_GetUISlotComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.SlotComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetUISlotComponent(
    game.Object self
);

void RegisterToHUDManagerByTask(bool shouldRegister) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "RegisterToHUDManagerByTask;Bool",
    (Object_RegisterToHUDManagerByTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_RegisterToHUDManagerByTask(
    game.Object self,
    bool shouldRegister
);

void RegisterToHUDManagerTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "RegisterToHUDManagerTask;ScriptTaskData",
    (Object_RegisterToHUDManagerTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void RegisterToHUDManager(bool shouldRegister) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "RegisterToHUDManager;Bool",
    (Object_RegisterToHUDManager x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_RegisterToHUDManager(
    game.Object self,
    bool shouldRegister
);

void HandleDeathByTask(WeakHandle<game.Object> instigator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "HandleDeathByTask;GameObject",
    (Object_HandleDeathByTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void HandleDeathTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "HandleDeathTask;ScriptTaskData",
    (Object_HandleDeathTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

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

Generated hook

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

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

bool OnDeviceLinkRequest(DeviceLinkRequest evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_OnDeviceLinkRequest(
    game.Object self,
    DeviceLinkRequest? evt
);

DeviceLinkComponentPS? GetDeviceLink() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetDeviceLink;",
    (Object_GetDeviceLink x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.DeviceLinkComponentPS>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetDeviceLink(
    game.Object self
);

void OnTransformUpdated() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "OnTransformUpdated;",
    (Object_OnTransformUpdated x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnTransformUpdated(
    game.Object self
);

game.PersistentID GetPersistentID() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetPersistentID;",
    (Object_GetPersistentID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.PersistentID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetPersistentID(
    game.Object self
);

PSOwnerData GetPSOwnerData() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetPSOwnerData;",
    (Object_GetPSOwnerData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.PSOwnerData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetPSOwnerData(
    game.Object self
);

CName GetPSClassName() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetPSClassName;",
    (Object_GetPSClassName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetPSClassName(
    game.Object self
);

void SendEventToDefaultPS(red.Event evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "SendEventToDefaultPS;Event",
    (Object_SendEventToDefaultPS x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SendEventToDefaultPS(
    game.Object self,
    red.Event? evt
);

bool IsConnectedToSecuritySystem() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsConnectedToSecuritySystem(
    game.Object self
);

SecuritySystemControllerPS? GetSecuritySystem() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_GetSecuritySystem(
    game.Object self
);

bool IsTargetTresspassingMyZone(game.Object target) RTTI

Generated hook

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

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

bool OnAddOrRemoveListenerForGameObject(AddOrRemoveListenerForGOEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnAddOrRemoveListenerForGameObject",
    (Object_OnAddOrRemoveListenerForGameObject x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnAddOrRemoveListenerForGameObject(
    game.Object self,
    AddOrRemoveListenerForGOEvent? evt
);

bool OnAddStatusEffectTriggerListener(AddStatusEffectListenerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnAddStatusEffectTriggerListener",
    (Object_OnAddStatusEffectTriggerListener x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnAddStatusEffectTriggerListener(
    game.Object self,
    AddStatusEffectListenerEvent? evt
);

bool OnRemoveStatusEffectTriggerListener(RemoveStatusEffectListenerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnRemoveStatusEffectTriggerListener",
    (Object_OnRemoveStatusEffectTriggerListener x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnRemoveStatusEffectTriggerListener(
    game.Object self,
    RemoveStatusEffectListenerEvent? evt
);

bool OnRequestComponents(ent.EntityRequestComponentsInterface ri) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_OnRequestComponents(
    game.Object self,
    ent.EntityRequestComponentsInterface ri
);

bool OnTakeControl(ent.EntityResolveComponentsInterface ri) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_OnTakeControl(
    game.Object self,
    ent.EntityResolveComponentsInterface ri
);

bool OnPostInitialize(ent.PostInitializeEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_OnPostInitialize(
    game.Object self,
    ent.PostInitializeEvent? evt
);

bool OnPreUninitialize(ent.PreUninitializeEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_OnPreUninitialize(
    game.Object self,
    ent.PreUninitializeEvent? evt
);

bool OnGameAttached() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_OnGameAttached(
    game.Object self
);

bool OnDetach() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_OnDetach(
    game.Object self
);

bool ShouldForceRegisterInHUDManager() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "ShouldForceRegisterInHUDManager;",
    (Object_ShouldForceRegisterInHUDManager x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ShouldForceRegisterInHUDManager(
    game.Object self
);

bool ShouldRegisterToHUD() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_ShouldRegisterToHUD(
    game.Object self
);

void RequestHUDRefresh(HUDActorUpdateData? updateData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "RequestHUDRefresh;HUDActorUpdateData",
    (Object_RequestHUDRefresh x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_RequestHUDRefresh(
    game.Object self,
    HUDActorUpdateData? updateData
);

void RequestHUDRefresh(ent.EntityID targetID, HUDActorUpdateData? updateData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "RequestHUDRefresh;EntityIDHUDActorUpdateData",
    (Object_RequestHUDRefresh2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_RequestHUDRefresh2(
    game.Object self,
    ent.EntityID targetID,
    HUDActorUpdateData? updateData
);

bool CanPlayerScanThroughWalls() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "CanPlayerScanThroughWalls;",
    (Object_CanPlayerScanThroughWalls x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_CanPlayerScanThroughWalls(
    game.Object self
);

bool IsScannerDataDirty() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsScannerDataDirty;",
    (Object_IsScannerDataDirty x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsScannerDataDirty(
    game.Object self
);

void SetScannerDirty(bool dirty) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "SetScannerDirty;Bool",
    (Object_SetScannerDirty x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SetScannerDirty(
    game.Object self,
    bool dirty
);

bool CanRevealRemoteActionsWheel() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_CanRevealRemoteActionsWheel(
    game.Object self
);

bool IsInitialized() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsInitialized;",
    (Object_IsInitialized x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsInitialized(
    game.Object self
);

bool ShouldReactToTarget(ent.EntityID targetID) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "ShouldReactToTarget;EntityID",
    (Object_ShouldReactToTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ShouldReactToTarget(
    game.Object self,
    ent.EntityID targetID
);

sense.Component? GetSensesComponent() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_GetSensesComponent(
    game.Object self
);

game.AttitudeAgent? GetAttitudeAgent() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_GetAttitudeAgent(
    game.Object self
);

TDBID GetScannerAttitudeTweak() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetScannerAttitudeTweak;",
    (Object_GetScannerAttitudeTweak x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetScannerAttitudeTweak(
    game.Object self
);

EAIAttitude GetAttitudeTowards(game.Object target) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetAttitudeTowards;GameObject",
    (Object_GetAttitudeTowards x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EAIAttitude>();
    }
);

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

bool HasAttitude(EAIAttitude attitude) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "HasAttitude;EAIAttitude",
    (Object_HasAttitude x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasAttitude(
    game.Object self,
    EAIAttitude attitude
);

bool IsHostile() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsHostile;",
    (Object_IsHostile x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsHostile(
    game.Object self
);

bool IsNeutral() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsNeutral;",
    (Object_IsNeutral x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsNeutral(
    game.Object self
);

AITargetTrackerComponent? GetTargetTrackerComponent() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_GetTargetTrackerComponent(
    game.Object self
);

ent.Entity?[] GetEntitiesAroundObject(float? range, game.TargetSearchFilter? searchFilter) RTTI
NPCPuppet?[] GetNPCsAroundObject(float? range) RTTI

void OnEventReplicated(red.Event evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "OnEventReplicated;Event",
    (Object_OnEventReplicated x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnEventReplicated(
    game.Object self,
    red.Event? evt
);

void PassUpdate(float dt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "PassUpdate;Float",
    (Object_PassUpdate x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_PassUpdate(
    game.Object self,
    float dt
);

void Update(float dt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_Update(
    game.Object self,
    float dt
);

bool OnStatusEffectApplied(game.events.ApplyStatusEffectEvent evt) RTTI

Generated hook

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

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

void HandleICEBreakerUpdate(game.events.ApplyStatusEffectEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "HandleICEBreakerUpdate;ApplyStatusEffectEvent",
    (Object_HandleICEBreakerUpdate x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void StartStatusEffectVFX(game.events.ApplyStatusEffectEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "StartStatusEffectVFX;ApplyStatusEffectEvent",
    (Object_StartStatusEffectVFX x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void StartStatusEffectSFX(game.events.ApplyStatusEffectEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "StartStatusEffectSFX;ApplyStatusEffectEvent",
    (Object_StartStatusEffectSFX x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool OnStatusEffectRemoved(game.events.RemoveStatusEffect evt) RTTI

Generated hook

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

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

void StopStatusEffectVFX(game.events.RemoveStatusEffect evt) RTTI

Generated hook

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

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

void StopStatusEffectSFX(game.events.RemoveStatusEffect evt) RTTI

Generated hook

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

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

bool OnHit(game.events.HitEvent evt) RTTI

Generated hook

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

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

bool OnMiss(game.events.MissEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnMiss",
    (Object_OnMiss x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnMiss(
    game.Object self,
    game.events.MissEvent? evt
);

void DamagePipelineFinalized(game.events.HitEvent evt) RTTI

Generated hook

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

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

bool ResolveHitIstigatorCooldown(ent.EntityID instigatorID) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "ResolveHitIstigatorCooldown;EntityID",
    (Object_ResolveHitIstigatorCooldown x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ResolveHitIstigatorCooldown(
    game.Object self,
    ent.EntityID instigatorID
);

bool OnHitInstigatorCooldown(HitInstigatorCooldownEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnHitInstigatorCooldown",
    (Object_OnHitInstigatorCooldown x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnHitInstigatorCooldown(
    game.Object self,
    HitInstigatorCooldownEvent? evt
);

void HandleStimsOnHit(game.events.HitEvent evt) RTTI

Generated hook

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

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

bool OnVehicleHit(game.events.VehicleHitEvent evt) RTTI

Generated hook

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

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

bool OnHitProjection(game.events.ProjectedHitEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnHitProjection",
    (Object_OnHitProjection x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnHitProjection(
    game.Object self,
    game.events.ProjectedHitEvent? evt
);

bool OnAttitudeChanged(game.events.AttitudeChangedEvent evt) RTTI

Generated hook

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

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

void ProcessDamagePipeline(game.events.HitEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "ProcessDamagePipeline;gameHitEvent",
    (Object_ProcessDamagePipeline x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void ReactToHitProcess(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "ReactToHitProcess;gameHitEvent",
    (Object_ReactToHitProcess x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void OnHitBlockedOrDeflected(game.events.HitEvent hitEvent) RTTI

Generated hook

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

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

void OnHitAnimation(game.events.HitEvent hitEvent) RTTI

Generated hook

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

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

void OnHitUI(game.events.HitEvent hitEvent) RTTI

Generated hook

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

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

void DisplayHitUI(game.ui.DamageInfo[] dmgInfos) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "DisplayHitUI;script_ref<array<DamageInfo>>",
    (Object_DisplayHitUI x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_DisplayHitUI(
    game.Object self,
    game.ui.DamageInfo[] dmgInfos
);

void DisplayKillUI(game.ui.KillInfo killInfo) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "DisplayKillUI;KillInfo",
    (Object_DisplayKillUI x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_DisplayKillUI(
    game.Object self,
    game.ui.KillInfo killInfo
);

void OnHitSounds(game.events.HitEvent hitEvent) RTTI

Generated hook

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

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

void OnHitVFX(game.events.HitEvent hitEvent) RTTI

Generated hook

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

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

bool OnDamageReceived(game.events.DamageReceivedEvent evt) RTTI

Generated hook

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

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

float GetReceivedDamageByPlayerLastTimeStamp() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetReceivedDamageByPlayerLastTimeStamp;",
    (Object_GetReceivedDamageByPlayerLastTimeStamp x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetReceivedDamageByPlayerLastTimeStamp(
    game.Object self
);

void ProcessDamageReceived(game.events.DamageReceivedEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "ProcessDamageReceived;gameDamageReceivedEvent",
    (Object_ProcessDamageReceived x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void Record1DamageInHistory(game.Object source) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "Record1DamageInHistory;GameObject",
    (Object_Record1DamageInHistory x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_Record1DamageInHistory(
    game.Object self,
    game.Object? source
);

bool OnRecord1DamageInHistoryEvent(Record1DamageInHistoryEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnRecord1DamageInHistoryEvent",
    (Object_OnRecord1DamageInHistoryEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnRecord1DamageInHistoryEvent(
    game.Object self,
    Record1DamageInHistoryEvent? evt
);

void FindAndRewardKiller(game.KillType killType, WeakHandle<game.Object>? instigator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "FindAndRewardKiller;gameKillTypeGameObject",
    (Object_FindAndRewardKiller x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

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

Generated hook

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

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

void ForceDefeatReward(bool value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "ForceDefeatReward;Bool",
    (Object_ForceDefeatReward x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ForceDefeatReward(
    game.Object self,
    bool value
);

void DisableKillReward(bool value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "DisableKillReward;Bool",
    (Object_DisableKillReward x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_DisableKillReward(
    game.Object self,
    bool value
);

bool OnChangeRewardSettingsEvent(ChangeRewardSettingsEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnChangeRewardSettingsEvent",
    (Object_OnChangeRewardSettingsEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnChangeRewardSettingsEvent(
    game.Object self,
    ChangeRewardSettingsEvent? evt
);

bool OnWillDieSoonEventEvent(WillDieSoonEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnWillDieSoonEventEvent",
    (Object_OnWillDieSoonEventEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnWillDieSoonEventEvent(
    game.Object self,
    WillDieSoonEvent? evt
);

void CheckIfPreventionShouldReact(WeakHandle<game.Object>[] damageDealers) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "CheckIfPreventionShouldReact;script_ref<array<GameObject>>",
    (Object_CheckIfPreventionShouldReact x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool IsVehicle() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsVehicle;",
    (Object_IsVehicle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsVehicle(
    game.Object self
);

bool IsPuppet() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsPuppet(
    game.Object self
);

bool IsPlayer() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsPlayer(
    game.Object self
);

bool IsPaperdoll() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsPaperdoll(
    game.Object self
);

bool IsReplacer() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsReplacer(
    game.Object self
);

bool IsVRReplacer() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsVRReplacer(
    game.Object self
);

bool IsJohnnyReplacer() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsJohnnyReplacer(
    game.Object self
);

bool IsNPC() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsNPC(
    game.Object self
);

bool IsContainer() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsContainer(
    game.Object self
);

bool IsShardContainer() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsShardContainer;",
    (Object_IsShardContainer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsShardContainer(
    game.Object self
);

bool IsPlayerStash() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsPlayerStash;",
    (Object_IsPlayerStash x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsPlayerStash(
    game.Object self
);

bool IsDevice() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsDevice;",
    (Object_IsDevice x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsDevice(
    game.Object self
);

bool IsSensor() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsSensor;",
    (Object_IsSensor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsSensor(
    game.Object self
);

bool IsTurret() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsTurret;",
    (Object_IsTurret x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsTurret(
    game.Object self
);

bool IsActive() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsActive(
    game.Object self
);

bool IsPrevention() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsPrevention(
    game.Object self
);

bool IsDropPoint() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsDropPoint;",
    (Object_IsDropPoint x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsDropPoint(
    game.Object self
);

bool IsWardrobe() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsWardrobe;",
    (Object_IsWardrobe x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsWardrobe(
    game.Object self
);

bool IsDrone() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsDrone(
    game.Object self
);

bool IsValidHostileTarget() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsValidHostileTarget;",
    (Object_IsValidHostileTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsValidHostileTarget(
    game.Object self
);

bool IsItem() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsItem;",
    (Object_IsItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsItem(
    game.Object self
);

bool IsDead() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsDead(
    game.Object self
);

bool IsDeadNoStatPool() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsDeadNoStatPool(
    game.Object self
);

void UpdateAdditionalScanningData() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_UpdateAdditionalScanningData(
    game.Object self
);

bool OnOutlineRequestEvent(OutlineRequestEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_OnOutlineRequestEvent(
    game.Object self,
    OutlineRequestEvent? evt
);

bool OnDebugOutlineEvent(DebugOutlineEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnDebugOutlineEvent",
    (Object_OnDebugOutlineEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnDebugOutlineEvent(
    game.Object self,
    DebugOutlineEvent? evt
);

bool OnScanningModeChanged(game.ScanningModeEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnScanningModeChanged",
    (Object_OnScanningModeChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnScanningModeChanged(
    game.Object self,
    game.ScanningModeEvent? evt
);

bool OnScanningLookedAt(game.ScanningLookAtEvent evt) RTTI

Generated hook

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

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

bool OnLookedAtEvent(LookedAtEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_OnLookedAtEvent(
    game.Object self,
    LookedAtEvent? evt
);

bool OnPulseEvent(game.VisionModeUpdateVisuals evt) RTTI

Generated hook

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

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

void PulseNetwork(bool revealNetworkAtEnd) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_PulseNetwork(
    game.Object self,
    bool revealNetworkAtEnd
);

TakeOverControlSystem? GetTakeOverControlSystem() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetTakeOverControlSystem;",
    (Object_GetTakeOverControlSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TakeOverControlSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetTakeOverControlSystem(
    game.Object self
);

game.Object? TryGetControlledProxy() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "TryGetControlledProxy;",
    (Object_TryGetControlledProxy x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_TryGetControlledProxy(
    game.Object self
);

FocusModeTaggingSystem? GetTaggingSystem() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetTaggingSystem;",
    (Object_GetTaggingSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.FocusModeTaggingSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetTaggingSystem(
    game.Object self
);

bool CanBeTagged() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_CanBeTagged(
    game.Object self
);

bool OnTagObjectEvent(TagObjectEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnTagObjectEvent",
    (Object_OnTagObjectEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnTagObjectEvent(
    game.Object self,
    TagObjectEvent? evt
);

FocusForcedHighlightData? GetDefaultHighlight() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_GetDefaultHighlight(
    game.Object self
);

void UpdateDefaultHighlight() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "UpdateDefaultHighlight;",
    (Object_UpdateDefaultHighlight x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_UpdateDefaultHighlight(
    game.Object self
);

EFocusOutlineType GetCurrentOutline() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_GetCurrentOutline(
    game.Object self
);

EFocusForcedHighlightType GetDefaultHighlightType() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetDefaultHighlightType;",
    (Object_GetDefaultHighlightType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EFocusForcedHighlightType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetDefaultHighlightType(
    game.Object self
);

bool HasHighlight(EFocusForcedHighlightType highlightType, EFocusOutlineType outlineType) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "HasHighlight;EFocusForcedHighlightTypeEFocusOutlineType",
    (Object_HasHighlight x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasHighlight(
    game.Object self,
    EFocusForcedHighlightType highlightType,
    EFocusOutlineType outlineType
);

bool HasOutlineOrFill(EFocusForcedHighlightType highlightType, EFocusOutlineType outlineType) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "HasOutlineOrFill;EFocusForcedHighlightTypeEFocusOutlineType",
    (Object_HasOutlineOrFill x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasOutlineOrFill(
    game.Object self,
    EFocusForcedHighlightType highlightType,
    EFocusOutlineType outlineType
);

bool HasHighlight(EFocusForcedHighlightType highlightType, EFocusOutlineType outlineType, ent.EntityID sourceID) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "HasHighlight;EFocusForcedHighlightTypeEFocusOutlineTypeEntityID",
    (Object_HasHighlight2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasHighlight2(
    game.Object self,
    EFocusForcedHighlightType highlightType,
    EFocusOutlineType outlineType,
    ent.EntityID sourceID
);

bool HasHighlight(EFocusForcedHighlightType highlightType, EFocusOutlineType outlineType, ent.EntityID sourceID, CName sourceName)

RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "HasHighlight;EFocusForcedHighlightTypeEFocusOutlineTypeEntityIDCName",
    (Object_HasHighlight3 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasHighlight3(
    game.Object self,
    EFocusForcedHighlightType highlightType,
    EFocusOutlineType outlineType,
    ent.EntityID sourceID,
    CName sourceName
);

bool HasRevealRequest(game.VisionModeSystemRevealIdentifier data) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "HasRevealRequest;gameVisionModeSystemRevealIdentifier",
    (Object_HasRevealRequest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasRevealRequest(
    game.Object self,
    game.VisionModeSystemRevealIdentifier data
);

void CancelForcedVisionAppearance(FocusForcedHighlightData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "CancelForcedVisionAppearance;FocusForcedHighlightData",
    (Object_CancelForcedVisionAppearance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_CancelForcedVisionAppearance(
    game.Object self,
    FocusForcedHighlightData? data
);

void ForceVisionAppearance(FocusForcedHighlightData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "ForceVisionAppearance;FocusForcedHighlightData",
    (Object_ForceVisionAppearance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ForceVisionAppearance(
    game.Object self,
    FocusForcedHighlightData? data
);

void SendReactivateHighlightEvent() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "SendReactivateHighlightEvent;",
    (Object_SendReactivateHighlightEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SendReactivateHighlightEvent(
    game.Object self
);

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

bool OnHUDInstruction(HUDInstruction evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_OnHUDInstruction(
    game.Object self,
    HUDInstruction? evt
);

void TryOpenQuickhackMenu(bool shouldOpen) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "TryOpenQuickhackMenu;Bool",
    (Object_TryOpenQuickhackMenu x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_TryOpenQuickhackMenu(
    game.Object self,
    bool shouldOpen
);

void SendQuickhackCommands(bool shouldOpen) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_SendQuickhackCommands(
    game.Object self,
    bool shouldOpen
);

void SetCurrentlyUploadingAction(ScriptableDeviceAction action) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_SetCurrentlyUploadingAction(
    game.Object self,
    ScriptableDeviceAction? action
);

ScriptableDeviceAction? GetCurrentlyUploadingAction() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_GetCurrentlyUploadingAction(
    game.Object self
);

void SendForceRevealObjectEvent(bool reveal, CName reason, ent.EntityID? instigatorID, float? lifetime, float? delay) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "SendForceRevealObjectEvent;BoolCNameEntityIDFloatFloat",
    (Object_SendForceRevealObjectEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SendForceRevealObjectEvent(
    game.Object self,
    bool reveal,
    CName reason,
    ent.EntityID? instigatorID,
    float? lifetime,
    float? delay
);

void RestoreRevealState() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "RestoreRevealState;",
    (Object_RestoreRevealState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_RestoreRevealState(
    game.Object self
);

bool HasFinisherAvailable() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "HasFinisherAvailable;",
    (Object_HasFinisherAvailable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasFinisherAvailable(
    game.Object self
);

bool BlockWorkspotFinishers() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "BlockWorkspotFinishers;",
    (Object_BlockWorkspotFinishers x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_BlockWorkspotFinishers(
    game.Object self
);

bool BlockFinisherThreshold() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "BlockFinisherThreshold;",
    (Object_BlockFinisherThreshold x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_BlockFinisherThreshold(
    game.Object self
);

bool CanReceivePoiseDamage() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "CanReceivePoiseDamage;",
    (Object_CanReceivePoiseDamage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_CanReceivePoiseDamage(
    game.Object self
);

bool IsInFinisherHealthThreshold(WeakHandle<game.Object> playerPuppet) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsInFinisherHealthThreshold;GameObject",
    (Object_IsInFinisherHealthThreshold x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool GetIsInFastFinisher() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetIsInFastFinisher;",
    (Object_GetIsInFastFinisher x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetIsInFastFinisher(
    game.Object self
);

bool IsHighlightedInFocusMode() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsHighlightedInFocusMode;",
    (Object_IsHighlightedInFocusMode x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsHighlightedInFocusMode(
    game.Object self
);

bool IsScanned() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsScanned;",
    (Object_IsScanned x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsScanned(
    game.Object self
);

braindance.VisionMode GetBraindanceLayer() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetBraindanceLayer;",
    (Object_GetBraindanceLayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.braindance.VisionMode>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetBraindanceLayer(
    game.Object self
);

bool IsObjectRevealed() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsObjectRevealed;",
    (Object_IsObjectRevealed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsObjectRevealed(
    game.Object self
);

FastTravelSystem? GetFastTravelSystem() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetFastTravelSystem;",
    (Object_GetFastTravelSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.FastTravelSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetFastTravelSystem(
    game.Object self
);

NetworkSystem? GetNetworkSystem() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetNetworkSystem;",
    (Object_GetNetworkSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.NetworkSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetNetworkSystem(
    game.Object self
);

bool CanOverrideNetworkContext() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_CanOverrideNetworkContext(
    game.Object self
);

bool IsAccessPoint() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsAccessPoint;",
    (Object_IsAccessPoint x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsAccessPoint(
    game.Object self
);

void StartPingingNetwork() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_StartPingingNetwork(
    game.Object self
);

void StopPingingNetwork() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_StopPingingNetwork(
    game.Object self
);

CName GetNetworkLinkSlotName(out WorldTransform transform) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_GetNetworkLinkSlotName(
    game.Object self,
    WorldTransform transform
);

CName GetNetworkLinkSlotName() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_GetNetworkLinkSlotName2(
    game.Object self
);

CName GetRoleMappinSlotName() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetRoleMappinSlotName;",
    (Object_GetRoleMappinSlotName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetRoleMappinSlotName(
    game.Object self
);

CName GetQuickHackIndicatorSlotName() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetQuickHackIndicatorSlotName;",
    (Object_GetQuickHackIndicatorSlotName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetQuickHackIndicatorSlotName(
    game.Object self
);

CName GetPhoneCallIndicatorSlotName() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_GetPhoneCallIndicatorSlotName(
    game.Object self
);

bool IsNetworkLinkDynamic() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsNetworkLinkDynamic(
    game.Object self
);

Vector4 GetNetworkBeamEndpoint() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetNetworkBeamEndpoint;",
    (Object_GetNetworkBeamEndpoint x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetNetworkBeamEndpoint(
    game.Object self
);

bool IsNetworkKnownToPlayer() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsNetworkKnownToPlayer(
    game.Object self
);

bool CanPlayerUseQuickHackVulnerability(TDBID data) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "CanPlayerUseQuickHackVulnerability;TweakDBID",
    (Object_CanPlayerUseQuickHackVulnerability x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_CanPlayerUseQuickHackVulnerability(
    game.Object self,
    TDBID data
);

bool IsConnectedToBackdoorDevice() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsConnectedToBackdoorDevice(
    game.Object self
);

bool IsInIconForcedVisibilityRange() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsInIconForcedVisibilityRange;",
    (Object_IsInIconForcedVisibilityRange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsInIconForcedVisibilityRange(
    game.Object self
);

void EvaluateMappinsVisualState() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "EvaluateMappinsVisualState;",
    (Object_EvaluateMappinsVisualState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_EvaluateMappinsVisualState(
    game.Object self
);

bool IsGameplayRelevant() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsGameplayRelevant;",
    (Object_IsGameplayRelevant x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsGameplayRelevant(
    game.Object self
);

bool ShouldSendGameAttachedEventToPS() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "ShouldSendGameAttachedEventToPS;",
    (Object_ShouldSendGameAttachedEventToPS x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ShouldSendGameAttachedEventToPS(
    game.Object self
);

TDBID GetContentScale() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetContentScale;",
    (Object_GetContentScale x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetContentScale(
    game.Object self
);

bool IsGameplayRoleValid(EGameplayRole role) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsGameplayRoleValid;EGameplayRole",
    (Object_IsGameplayRoleValid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsGameplayRoleValid(
    game.Object self,
    EGameplayRole role
);

EGameplayRole DeterminGameplayRole() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_DeterminGameplayRole(
    game.Object self
);

EMappinVisualState DeterminGameplayRoleMappinVisuaState(SDeviceMappinData data) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "DeterminGameplayRoleMappinVisuaState;script_ref<SDeviceMappinData>",
    (Object_DeterminGameplayRoleMappinVisuaState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EMappinVisualState>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_DeterminGameplayRoleMappinVisuaState(
    game.Object self,
    SDeviceMappinData data
);

float DeterminGameplayRoleMappinRange(SDeviceMappinData data) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "DeterminGameplayRoleMappinRange;script_ref<SDeviceMappinData>",
    (Object_DeterminGameplayRoleMappinRange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_DeterminGameplayRoleMappinRange(
    game.Object self,
    SDeviceMappinData data
);

bool OnGameplayRoleChangeNotification(GameplayRoleChangeNotification evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnGameplayRoleChangeNotification",
    (Object_OnGameplayRoleChangeNotification x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnGameplayRoleChangeNotification(
    game.Object self,
    GameplayRoleChangeNotification? evt
);

bool IsHackingPlayer() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsHackingPlayer(
    game.Object self
);

bool IsQuickHackAble() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsQuickHackAble(
    game.Object self
);

bool IsQuickHacksExposed() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsQuickHacksExposed(
    game.Object self
);

bool IsBreached() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsBreached(
    game.Object self
);

bool IsBackdoor() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsBackdoor(
    game.Object self
);

bool IsActiveBackdoor() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsActiveBackdoor(
    game.Object self
);

bool IsBodyDisposalPossible() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsBodyDisposalPossible;",
    (Object_IsBodyDisposalPossible x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsBodyDisposalPossible(
    game.Object self
);

bool IsControllingDevices() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsControllingDevices;",
    (Object_IsControllingDevices x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsControllingDevices(
    game.Object self
);

bool HasAnySlaveDevices() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "HasAnySlaveDevices;",
    (Object_HasAnySlaveDevices x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasAnySlaveDevices(
    game.Object self
);

bool IsFastTravelPoint() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsFastTravelPoint;",
    (Object_IsFastTravelPoint x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsFastTravelPoint(
    game.Object self
);

bool IsExplosive() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsExplosive;",
    (Object_IsExplosive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsExplosive(
    game.Object self
);

bool HasImportantInteraction() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "HasImportantInteraction;",
    (Object_HasImportantInteraction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasImportantInteraction(
    game.Object self
);

bool HasAnyDirectInteractionActive() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "HasAnyDirectInteractionActive;",
    (Object_HasAnyDirectInteractionActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasAnyDirectInteractionActive(
    game.Object self
);

bool ShouldEnableRemoteLayer() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_ShouldEnableRemoteLayer(
    game.Object self
);

bool IsTechie() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsTechie;",
    (Object_IsTechie x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsTechie(
    game.Object self
);

bool IsSolo() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsSolo;",
    (Object_IsSolo x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsSolo(
    game.Object self
);

bool IsNetrunner() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsNetrunner;",
    (Object_IsNetrunner x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsNetrunner(
    game.Object self
);

bool IsAnyPlaystyleValid() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsAnyPlaystyleValid;",
    (Object_IsAnyPlaystyleValid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsAnyPlaystyleValid(
    game.Object self
);

bool IsHackingSkillCheckActive() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsHackingSkillCheckActive;",
    (Object_IsHackingSkillCheckActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsHackingSkillCheckActive(
    game.Object self
);

bool IsDemolitionSkillCheckActive() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsDemolitionSkillCheckActive;",
    (Object_IsDemolitionSkillCheckActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsDemolitionSkillCheckActive(
    game.Object self
);

bool IsEngineeringSkillCheckActive() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsEngineeringSkillCheckActive;",
    (Object_IsEngineeringSkillCheckActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsEngineeringSkillCheckActive(
    game.Object self
);

bool CanPassEngineeringSkillCheck() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "CanPassEngineeringSkillCheck;",
    (Object_CanPassEngineeringSkillCheck x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_CanPassEngineeringSkillCheck(
    game.Object self
);

bool CanPassDemolitionSkillCheck() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "CanPassDemolitionSkillCheck;",
    (Object_CanPassDemolitionSkillCheck x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_CanPassDemolitionSkillCheck(
    game.Object self
);

bool CanPassHackingSkillCheck() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "CanPassHackingSkillCheck;",
    (Object_CanPassHackingSkillCheck x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_CanPassHackingSkillCheck(
    game.Object self
);

bool HasDirectActionsActive() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_HasDirectActionsActive(
    game.Object self
);

bool HasActiveDistraction() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "HasActiveDistraction;",
    (Object_HasActiveDistraction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasActiveDistraction(
    game.Object self
);

bool HasActiveQuickHackUpload() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_HasActiveQuickHackUpload(
    game.Object self
);

bool IsInvestigating() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsInvestigating(
    game.Object self
);

bool IsInvestigatingObject(game.Object targetID) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsInvestigatingObject(
    game.Object self,
    game.Object? targetID
);

bool IsTaggedinFocusMode() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsTaggedinFocusMode;",
    (Object_IsTaggedinFocusMode x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsTaggedinFocusMode(
    game.Object self
);

bool IsQuest() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_IsQuest(
    game.Object self
);

bool OnSetAsQuestImportantEvent(game.SetAsQuestImportantEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnSetAsQuestImportantEvent",
    (Object_OnSetAsQuestImportantEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnSetAsQuestImportantEvent(
    game.Object self,
    game.SetAsQuestImportantEvent? evt
);

void ToggleQuestImportance(bool isImportant) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "ToggleQuestImportance;Bool",
    (Object_ToggleQuestImportance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ToggleQuestImportance(
    game.Object self,
    bool isImportant
);

void MarkAsQuest(bool isQuest) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "MarkAsQuest;Bool",
    (Object_MarkAsQuest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_MarkAsQuest(
    game.Object self,
    bool isQuest
);

bool IsGrouppedClue() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsGrouppedClue;",
    (Object_IsGrouppedClue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsGrouppedClue(
    game.Object self
);

bool HasAnyClue() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "HasAnyClue;",
    (Object_HasAnyClue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasAnyClue(
    game.Object self
);

bool IsClueInspected() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsClueInspected;",
    (Object_IsClueInspected x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsClueInspected(
    game.Object self
);

LinkedFocusClueData GetLinkedClueData(int clueIndex) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetLinkedClueData;Int32",
    (Object_GetLinkedClueData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.LinkedFocusClueData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetLinkedClueData(
    game.Object self,
    int clueIndex
);

int GetAvailableClueIndex() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetAvailableClueIndex;",
    (Object_GetAvailableClueIndex x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetAvailableClueIndex(
    game.Object self
);

void PurgeScannerBlackboard() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "PurgeScannerBlackboard;",
    (Object_PurgeScannerBlackboard x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_PurgeScannerBlackboard(
    game.Object self
);

bool OnlinkedClueTagEvent(linked.ClueTagEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnlinkedClueTagEvent",
    (Object_OnlinkedClueTagEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnlinkedClueTagEvent(
    game.Object self,
    linked.ClueTagEvent? evt
);

bool CompileScannerChunks() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_CompileScannerChunks(
    game.Object self
);

void FillObjectDescription(out game.ScanningTooltipElementDef[] arr) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "FillObjectDescription;array<ScanningTooltipElementDef>",
    (Object_FillObjectDescription x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_FillObjectDescription(
    game.Object self,
    game.ScanningTooltipElementDef[] arr
);

game.ScanningTooltipElementDef[] GetScannableObjects() RTTI

bool ShouldShowScanner() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_ShouldShowScanner(
    game.Object self
);

bool IsScaningCluesBlocked() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsScaningCluesBlocked;",
    (Object_IsScaningCluesBlocked x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsScaningCluesBlocked(
    game.Object self
);

bool IsBraindanceBlocked() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsBraindanceBlocked;",
    (Object_IsBraindanceBlocked x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsBraindanceBlocked(
    game.Object self
);

bool IsPhotoModeBlocked() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsPhotoModeBlocked;",
    (Object_IsPhotoModeBlocked x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsPhotoModeBlocked(
    game.Object self
);

void ResolveFocusClueExtendedDescription(int clueIndex) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "ResolveFocusClueExtendedDescription;Int32",
    (Object_ResolveFocusClueExtendedDescription x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ResolveFocusClueExtendedDescription(
    game.Object self,
    int clueIndex
);

void ResolveFocusClueConclusion(int clueIndex, game.ScanningTooltipElementDef conclusionData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "ResolveFocusClueConclusion;Int32ScanningTooltipElementDef",
    (Object_ResolveFocusClueConclusion x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ResolveFocusClueConclusion(
    game.Object self,
    int clueIndex,
    game.ScanningTooltipElementDef conclusionData
);

void ResolveFacts(SFactOperationData[] facts) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "ResolveFacts;script_ref<array<SFactOperationData>>",
    (Object_ResolveFacts x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ResolveFacts(
    game.Object self,
    SFactOperationData[] facts
);

FocusCluesSystem? GetFocusClueSystem() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetFocusClueSystem;",
    (Object_GetFocusClueSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.FocusCluesSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetFocusClueSystem(
    game.Object self
);

bool IsAnyClueEnabled() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsAnyClueEnabled;",
    (Object_IsAnyClueEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsAnyClueEnabled(
    game.Object self
);

bool HasAnyStoredClues() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "HasAnyStoredClues;",
    (Object_HasAnyStoredClues x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasAnyStoredClues(
    game.Object self
);

bool IsCurrentTarget() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsCurrentTarget;",
    (Object_IsCurrentTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsCurrentTarget(
    game.Object self
);

bool IsCurrentlyScanned() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsCurrentlyScanned;",
    (Object_IsCurrentlyScanned x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsCurrentlyScanned(
    game.Object self
);

NodeRef GetFreeWorkspotRefForAIAction(game.data.WorkspotActionType aiAction) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetFreeWorkspotRefForAIAction;gamedataWorkspotActionType",
    (Object_GetFreeWorkspotRefForAIAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.NodeRef>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetFreeWorkspotRefForAIAction(
    game.Object self,
    game.data.WorkspotActionType aiAction
);

WorkspotEntryData? GetFreeWorkspotDataForAIAction(game.data.WorkspotActionType aiAction) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetFreeWorkspotDataForAIAction;gamedataWorkspotActionType",
    (Object_GetFreeWorkspotDataForAIAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.WorkspotEntryData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetFreeWorkspotDataForAIAction(
    game.Object self,
    game.data.WorkspotActionType aiAction
);

bool HasFreeWorkspotForInvestigation() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "HasFreeWorkspotForInvestigation;",
    (Object_HasFreeWorkspotForInvestigation x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasFreeWorkspotForInvestigation(
    game.Object self
);

int GetFreeWorkspotsCountForAIAction(game.data.WorkspotActionType aiAction) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetFreeWorkspotsCountForAIAction;gamedataWorkspotActionType",
    (Object_GetFreeWorkspotsCountForAIAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetFreeWorkspotsCountForAIAction(
    game.Object self,
    game.data.WorkspotActionType aiAction
);

int GetNumberOfWorkpotsForAIAction(game.data.WorkspotActionType aiAction) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetNumberOfWorkpotsForAIAction;gamedataWorkspotActionType",
    (Object_GetNumberOfWorkpotsForAIAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetNumberOfWorkpotsForAIAction(
    game.Object self,
    game.data.WorkspotActionType aiAction
);

int GetTotalCountOfInvestigationSlots() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetTotalCountOfInvestigationSlots;",
    (Object_GetTotalCountOfInvestigationSlots x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetTotalCountOfInvestigationSlots(
    game.Object self
);

StimBroadcasterComponent? GetStimBroadcasterComponent() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetStimBroadcasterComponent;",
    (Object_GetStimBroadcasterComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.StimBroadcasterComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetStimBroadcasterComponent(
    game.Object self
);

SquadMemberBaseComponent? GetSquadMemberComponent() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetSquadMemberComponent;",
    (Object_GetSquadMemberComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.SquadMemberBaseComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetSquadMemberComponent(
    game.Object self
);

game.StatusEffectComponent? GetStatusEffectComponent() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetStatusEffectComponent;",
    (Object_GetStatusEffectComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.StatusEffectComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetStatusEffectComponent(
    game.Object self
);

game.SourceShootComponent? GetSourceShootComponent() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetSourceShootComponent;",
    (Object_GetSourceShootComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.SourceShootComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetSourceShootComponent(
    game.Object self
);

game.TargetShootComponent? GetTargetShootComponent() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetTargetShootComponent;",
    (Object_GetTargetShootComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TargetShootComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetTargetShootComponent(
    game.Object self
);

void OnAnimFeatureReplicated(CName inputName, anim.AnimFeature value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "OnAnimFeatureReplicated;CNameAnimFeature",
    (Object_OnAnimFeatureReplicated x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnAnimFeatureReplicated(
    game.Object self,
    CName inputName,
    anim.AnimFeature? value
);

void OnAnimEventReplicated(CName eventName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "OnAnimEventReplicated;CName",
    (Object_OnAnimEventReplicated x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnAnimEventReplicated(
    game.Object self,
    CName eventName
);

Vector4 GetPlaystyleMappinLocalPos() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetPlaystyleMappinLocalPos;",
    (Object_GetPlaystyleMappinLocalPos x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetPlaystyleMappinLocalPos(
    game.Object self
);

Vector4 GetPlaystyleMappinSlotWorldPos() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetPlaystyleMappinSlotWorldPos;",
    (Object_GetPlaystyleMappinSlotWorldPos x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetPlaystyleMappinSlotWorldPos(
    game.Object self
);

WorldTransform GetPlaystyleMappinSlotWorldTransform() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetPlaystyleMappinSlotWorldTransform;",
    (Object_GetPlaystyleMappinSlotWorldTransform x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.WorldTransform>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetPlaystyleMappinSlotWorldTransform(
    game.Object self
);

game.FxResource GetFxResourceByKey(CName key) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_GetFxResourceByKey(
    game.Object self,
    CName key
);

bool OnDelayPrereqEvent(DelayPrereqEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnDelayPrereqEvent",
    (Object_OnDelayPrereqEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnDelayPrereqEvent(
    game.Object self,
    DelayPrereqEvent? evt
);

bool OnTriggerAttackEffectorWithDelay(TriggerAttackEffectorWithDelay evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnTriggerAttackEffectorWithDelay",
    (Object_OnTriggerAttackEffectorWithDelay x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnTriggerAttackEffectorWithDelay(
    game.Object self,
    TriggerAttackEffectorWithDelay? evt
);

bool OnToggleOffMeshConnections(ToggleOffMeshConnections evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnToggleOffMeshConnections",
    (Object_OnToggleOffMeshConnections x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnToggleOffMeshConnections(
    game.Object self,
    ToggleOffMeshConnections? evt
);

void EnableOffMeshConnections(bool player, bool npc) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "EnableOffMeshConnections;BoolBool",
    (Object_EnableOffMeshConnections x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_EnableOffMeshConnections(
    game.Object self,
    bool player,
    bool npc
);

void DisableOffMeshConnections(bool player, bool npc) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "DisableOffMeshConnections;BoolBool",
    (Object_DisableOffMeshConnections x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_DisableOffMeshConnections(
    game.Object self,
    bool player,
    bool npc
);

bool OnPhysicalDestructionEvent(ent.PhysicalDestructionEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnPhysicalDestructionEvent",
    (Object_OnPhysicalDestructionEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnPhysicalDestructionEvent(
    game.Object self,
    ent.PhysicalDestructionEvent? evt
);

HUDManager? GetHudManager() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetHudManager;",
    (Object_GetHudManager x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.HUDManager>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetHudManager(
    game.Object self
);

void TriggerMenuEvent(CName eventName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "TriggerMenuEvent;CName",
    (Object_TriggerMenuEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_TriggerMenuEvent(
    game.Object self,
    CName eventName
);

Vector4 GetAcousticQuerryStartPoint() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetAcousticQuerryStartPoint;",
    (Object_GetAcousticQuerryStartPoint x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetAcousticQuerryStartPoint(
    game.Object self
);

bool CanBeInvestigated() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "CanBeInvestigated;",
    (Object_CanBeInvestigated x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_CanBeInvestigated(
    game.Object self
);

PreventionSystem? GetPreventionSystem() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetPreventionSystem;",
    (Object_GetPreventionSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.PreventionSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetPreventionSystem(
    game.Object self
);

game.data.Quality GetLootQuality() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_GetLootQuality(
    game.Object self
);

bool GetIsIconic() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Object_GetIsIconic(
    game.Object self
);

bool GetIsBroken() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetIsBroken;",
    (Object_GetIsBroken x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetIsBroken(
    game.Object self
);

bool IsAmmoLoot() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsAmmoLoot;",
    (Object_IsAmmoLoot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsAmmoLoot(
    game.Object self
);

bool IsSniperAmmoLoot() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsSniperAmmoLoot;",
    (Object_IsSniperAmmoLoot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsSniperAmmoLoot(
    game.Object self
);

bool IsHandgunAmmoLoot() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsHandgunAmmoLoot;",
    (Object_IsHandgunAmmoLoot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsHandgunAmmoLoot(
    game.Object self
);

bool IsShotgunAmmoLoot() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsShotgunAmmoLoot;",
    (Object_IsShotgunAmmoLoot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsShotgunAmmoLoot(
    game.Object self
);

bool IsRifleAmmoLoot() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsRifleAmmoLoot;",
    (Object_IsRifleAmmoLoot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsRifleAmmoLoot(
    game.Object self
);

bool OnScaleAndLockLeftHandWeaponsCompensateInStashEvent(ScaleAndLockLeftHandWeaponsCompensateInStashEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnScaleAndLockLeftHandWeaponsCompensateInStashEvent",
    (Object_OnScaleAndLockLeftHandWeaponsCompensateInStashEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnScaleAndLockLeftHandWeaponsCompensateInStashEvent(
    game.Object self,
    ScaleAndLockLeftHandWeaponsCompensateInStashEvent? evt
);

bool OnUnifyIconicsUpgradeCountWithEffectiveTierInStashEvent(UnifyIconicsUpgradeCountWithEffectiveTierInStashEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnUnifyIconicsUpgradeCountWithEffectiveTierInStashEvent",
    (Object_OnUnifyIconicsUpgradeCountWithEffectiveTierInStashEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnUnifyIconicsUpgradeCountWithEffectiveTierInStashEvent(
    game.Object self,
    UnifyIconicsUpgradeCountWithEffectiveTierInStashEvent? evt
);

AnimationSystemForcedVisibilityManager? GetAnimationSystemForcedVisibilityManager() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "GetAnimationSystemForcedVisibilityManager;",
    (Object_GetAnimationSystemForcedVisibilityManager x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.AnimationSystemForcedVisibilityManager>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetAnimationSystemForcedVisibilityManager(
    game.Object self
);

void ToggleForcedVisibilityInAnimSystem(CName sourceName, bool isVisibe, float? transitionTime, ent.EntityID? entityID, bool? forcedVisibleOnlyInFrustum)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "ToggleForcedVisibilityInAnimSystem;CNameBoolFloatEntityIDBool",
    (Object_ToggleForcedVisibilityInAnimSystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ToggleForcedVisibilityInAnimSystem(
    game.Object self,
    CName sourceName,
    bool isVisibe,
    float? transitionTime,
    ent.EntityID? entityID,
    bool? forcedVisibleOnlyInFrustum
);

void ClearForcedVisibilityInAnimSystem() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "ClearForcedVisibilityInAnimSystem;",
    (Object_ClearForcedVisibilityInAnimSystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ClearForcedVisibilityInAnimSystem(
    game.Object self
);

bool HasVisibilityForcedInAnimSystem() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "HasVisibilityForcedInAnimSystem;",
    (Object_HasVisibilityForcedInAnimSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasVisibilityForcedInAnimSystem(
    game.Object self
);

bool OnToggleVisibilityInAnimSystemEvent(ToggleVisibilityInAnimSystemEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnToggleVisibilityInAnimSystemEvent",
    (Object_OnToggleVisibilityInAnimSystemEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnToggleVisibilityInAnimSystemEvent(
    game.Object self,
    ToggleVisibilityInAnimSystemEvent? evt
);

bool OnCustomUIAnimationEvent(CustomUIAnimationEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnCustomUIAnimationEvent",
    (Object_OnCustomUIAnimationEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnCustomUIAnimationEvent(
    game.Object self,
    CustomUIAnimationEvent? evt
);

bool OnSmartGunLockEvent(game.smartGun.SmartGunLockEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnSmartGunLockEvent",
    (Object_OnSmartGunLockEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnSmartGunLockEvent(
    game.Object self,
    game.smartGun.SmartGunLockEvent? evt
);

bool IsTargetedWithSmartWeapon() RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "IsTargetedWithSmartWeapon;",
    (Object_IsTargetedWithSmartWeapon x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsTargetedWithSmartWeapon(
    game.Object self
);

void ProlongWeaponGlitchNPCDebuff(PlayerPuppet player) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "ProlongWeaponGlitchNPCDebuff;PlayerPuppet",
    (Object_ProlongWeaponGlitchNPCDebuff x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool OnAutoSaveEvent(AutoSaveEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "OnAutoSaveEvent",
    (Object_OnAutoSaveEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnAutoSaveEvent(
    game.Object self,
    AutoSaveEvent? evt
);

void RequestAutoSaveWithDelay(float value, int maxAttempts, bool isForced) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "RequestAutoSaveWithDelay;FloatInt32Bool",
    (Object_RequestAutoSaveWithDelay x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_RequestAutoSaveWithDelay(
    game.Object self,
    float value,
    int maxAttempts,
    bool isForced
);

bool RequestAutoSave(bool isForced) RTTI

Generated hook

re.Hooks.Place(
    "gameObject",
    "RequestAutoSave;Bool",
    (Object_RequestAutoSave x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_RequestAutoSave(
    game.Object self,
    bool isForced
);

static void ForceVisionAppearance(game.Object self, FocusForcedHighlightData data) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::ForceVisionAppearance;GameObjectFocusForcedHighlightData",
    (Object_ForceVisionAppearance2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ForceVisionAppearance2(
    game.Object? self,
    FocusForcedHighlightData? data
);

static bool IsCooldownActive(game.Object self, CName cooldownName, int id) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameObject",
    "gameObject::IsCooldownActive;GameObjectCNameInt32",
    (Object_IsCooldownActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsCooldownActive(
    game.Object? self,
    CName cooldownName,
    int id
);

static int GetTargetAngleInInt(game.Object target, game.Object owner, out int backDirection) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameObject",
    "gameObject::GetTargetAngleInInt;GameObjectGameObjectInt32",
    (Object_GetTargetAngleInInt x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetTargetAngleInInt(
    game.Object? target,
    game.Object? owner,
    int backDirection
);

static void BreakReplicatedEffectLoopEvent(game.Object self, CName effectName) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::BreakReplicatedEffectLoopEvent;GameObjectCName",
    (Object_BreakReplicatedEffectLoopEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_BreakReplicatedEffectLoopEvent(
    game.Object? self,
    CName effectName
);

static void StopSoundEvent(game.Object self, CName eventName) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::StopSoundEvent;GameObjectCName",
    (Object_StopSoundEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_StopSoundEvent(
    game.Object? self,
    CName eventName
);

static EAIAttitude GetAttitudeTowards(game.Object first, game.Object second) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameObject",
    "gameObject::GetAttitudeTowards;GameObjectGameObject",
    (Object_GetAttitudeTowards2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EAIAttitude>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetAttitudeTowards2(
    game.Object? first,
    game.Object? second
);

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

Generated hook

re.Hooks.Place(
    "gameObject",
    "gameObject::IsFriendlyTowardsPlayer;GameObject",
    (Object_IsFriendlyTowardsPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static void SetMeshAppearanceEvent(game.Object self, CName appearance) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::SetMeshAppearanceEvent;GameObjectCName",
    (Object_SetMeshAppearanceEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SetMeshAppearanceEvent(
    game.Object? self,
    CName appearance
);

static bool TargetIsStunned(WeakHandle<game.Object> target) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameObject",
    "gameObject::TargetIsStunned;GameObject",
    (Object_TargetIsStunned x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static void AudioParameter(game.Object self, CName parameterName, float parameterValue, CName emitterName) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::AudioParameter;GameObjectCNameFloatCName",
    (Object_AudioParameter x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_AudioParameter(
    game.Object? self,
    CName parameterName,
    float parameterValue,
    CName emitterName
);

static void StopReplicatedEffectEvent(game.Object self, CName effectName) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::StopReplicatedEffectEvent;GameObjectCName",
    (Object_StopReplicatedEffectEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_StopReplicatedEffectEvent(
    game.Object? self,
    CName effectName
);

static void PlaySoundEvent(game.Object self, CName eventName) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::PlaySoundEvent;GameObjectCName",
    (Object_PlaySoundEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_PlaySoundEvent(
    game.Object? self,
    CName eventName
);

static void RemoveStatusEffectTriggerListener(game.Object target, StatusEffectTriggerListener listener) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::RemoveStatusEffectTriggerListener;GameObjectStatusEffectTriggerListener",
    (Object_RemoveStatusEffectTriggerListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_RemoveStatusEffectTriggerListener(
    game.Object? target,
    StatusEffectTriggerListener? listener
);

static EAIAttitude GetAttitudeBetween(game.Object first, game.Object second) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameObject",
    "gameObject::GetAttitudeBetween;GameObjectGameObject",
    (Object_GetAttitudeBetween x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EAIAttitude>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetAttitudeBetween(
    game.Object? first,
    game.Object? second
);

static void PlaySoundEventWithParams(game.Object self, CName eventName, audio.AudioEventFlags flag, audio.EventActionType type)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::PlaySoundEventWithParams;GameObjectCNameaudioAudioEventFlagsaudioEventActionType",
    (Object_PlaySoundEventWithParams x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_PlaySoundEventWithParams(
    game.Object? self,
    CName eventName,
    audio.AudioEventFlags flag,
    audio.EventActionType type
);

static void ChangeAttitudeToNeutral(WeakHandle<game.Object> owner, WeakHandle<game.Object> target) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::ChangeAttitudeToNeutral;GameObjectGameObject",
    (Object_ChangeAttitudeToNeutral x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static void AudioSwitch(game.Object self, CName switchName, CName switchValue, CName emitterName) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::AudioSwitch;GameObjectCNameCNameCName",
    (Object_AudioSwitch x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_AudioSwitch(
    game.Object? self,
    CName switchName,
    CName switchValue,
    CName emitterName
);

static void SendForceRevealObjectEvent(game.Object self, bool reveal, CName reason, ent.EntityID instigatorID, float lifetime, float delay)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::SendForceRevealObjectEvent;GameObjectBoolCNameEntityIDFloatFloat",
    (Object_SendForceRevealObjectEvent2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SendForceRevealObjectEvent2(
    game.Object? self,
    bool reveal,
    CName reason,
    ent.EntityID instigatorID,
    float lifetime,
    float delay
);

static void RemoveModifierGroup(game.Object self, ulong modifierGroupID) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::RemoveModifierGroup;GameObjectUint64",
    (Object_RemoveModifierGroup x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_RemoveModifierGroup(
    game.Object? self,
    ulong modifierGroupID
);

static void ApplyModifierGroup(game.Object self, ulong modifierGroupID) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::ApplyModifierGroup;GameObjectUint64",
    (Object_ApplyModifierGroup x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ApplyModifierGroup(
    game.Object? self,
    ulong modifierGroupID
);

static void StopEffectEvent(game.Object self, ent.EntityID id, CName effectName) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::StopEffectEvent;GameObjectEntityIDCName",
    (Object_StopEffectEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_StopEffectEvent(
    game.Object? self,
    ent.EntityID id,
    CName effectName
);

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

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::UntagObject;GameObject",
    (Object_UntagObject x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static void ChangeAttitudeToHostile(WeakHandle<game.Object> owner, WeakHandle<game.Object> target) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::ChangeAttitudeToHostile;GameObjectGameObject",
    (Object_ChangeAttitudeToHostile x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

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

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::AddListener;GameObjectGameObjectListener",
    (Object_AddListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static void StopSound(game.Object self, CName eventName, CName emitterName) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::StopSound;GameObjectCNameCName",
    (Object_StopSound x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_StopSound(
    game.Object? self,
    CName eventName,
    CName emitterName
);

static int StartCooldown(game.Object self, CName cooldownName, float cooldownDuration, bool ignoreTimeDilation) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameObject",
    "gameObject::StartCooldown;GameObjectCNameFloatBool",
    (Object_StartCooldown x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_StartCooldown(
    game.Object? self,
    CName cooldownName,
    float cooldownDuration,
    bool ignoreTimeDilation
);

static bool TargetHasLocomotionMalfunction(WeakHandle<game.Object> target) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameObject",
    "gameObject::TargetHasLocomotionMalfunction;GameObject",
    (Object_TargetHasLocomotionMalfunction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static void SetAudioSwitch(game.Object self, CName switchName, CName switchValue) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::SetAudioSwitch;GameObjectCNameCName",
    (Object_SetAudioSwitch x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SetAudioSwitch(
    game.Object? self,
    CName switchName,
    CName switchValue
);

static TDBID GetTDBID(WeakHandle<game.Object> objectt) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameObject",
    "gameObject::GetTDBID;GameObject",
    (Object_GetTDBID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

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

static bool TargetHasDebuff(WeakHandle<game.Object> target) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameObject",
    "gameObject::TargetHasDebuff;GameObject",
    (Object_TargetHasDebuff x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static void SetAudioParameter(game.Object self, CName paramName, float paramValue) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::SetAudioParameter;GameObjectCNameFloat",
    (Object_SetAudioParameter x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SetAudioParameter(
    game.Object? self,
    CName paramName,
    float paramValue
);

static float GetTargetAngleInFloat(game.Object target, game.Object owner) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameObject",
    "gameObject::GetTargetAngleInFloat;GameObjectGameObject",
    (Object_GetTargetAngleInFloat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

static void AddStatusEffectTriggerListener(game.Object target, StatusEffectTriggerListener listener) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::AddStatusEffectTriggerListener;GameObjectStatusEffectTriggerListener",
    (Object_AddStatusEffectTriggerListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_AddStatusEffectTriggerListener(
    game.Object? target,
    StatusEffectTriggerListener? listener
);

static void ToggleForcedVisibilityInAnimSystemEvent(game.Object owner, CName sourceName, bool isVisibe, float transitionTime)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::ToggleForcedVisibilityInAnimSystemEvent;GameObjectCNameBoolFloat",
    (Object_ToggleForcedVisibilityInAnimSystemEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ToggleForcedVisibilityInAnimSystemEvent(
    game.Object? owner,
    CName sourceName,
    bool isVisibe,
    float transitionTime
);

static bool IsVehicle(WeakHandle<game.Object> objectt) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameObject",
    "gameObject::IsVehicle;GameObject",
    (Object_IsVehicle2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static int GetAttackAngleInInt(game.events.HitEvent hitEvent, int hitSource) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameObject",
    "gameObject::GetAttackAngleInInt;gameHitEventInt32",
    (Object_GetAttackAngleInInt x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetAttackAngleInInt(
    game.events.HitEvent? hitEvent,
    int hitSource
);

static void PlayMetadataEvent(game.Object self, CName eventName) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::PlayMetadataEvent;GameObjectCName",
    (Object_PlayMetadataEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_PlayMetadataEvent(
    game.Object? self,
    CName eventName
);

static game.weapon.Object? GetActiveWeapon(WeakHandle<game.Object> objectt) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameObject",
    "gameObject::GetActiveWeapon;GameObject",
    (Object_GetActiveWeapon x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.weapon.GameWeaponObject>();
    }
);

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

static FocusForcedHighlightData? SetFocusForcedHightlightData(EFocusOutlineType outType, EFocusForcedHighlightType highType, EPriority prio, ent.EntityID id, CName className)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameObject",
    "gameObject::SetFocusForcedHightlightData;EFocusOutlineTypeEFocusForcedHighlightTypeEPriorityEntityIDCName",
    (Object_SetFocusForcedHightlightData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.FocusForcedHighlightData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SetFocusForcedHightlightData(
    EFocusOutlineType outType,
    EFocusForcedHighlightType highType,
    EPriority prio,
    ent.EntityID id,
    CName className
);

static void RemoveCooldown(game.Object self, CName cooldownName) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::RemoveCooldown;GameObjectCName",
    (Object_RemoveCooldown x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_RemoveCooldown(
    game.Object? self,
    CName cooldownName
);

static game.DelayID PlayVoiceOver(game.Object self, CName voName, CName debugInitialContext, float delay, ent.EntityID answeringEntityID, bool canPlayInVehicle)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameObject",
    "gameObject::PlayVoiceOver;GameObjectCNameCNameFloatEntityIDBool",
    (Object_PlayVoiceOver x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.DelayID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_PlayVoiceOver(
    game.Object? self,
    CName voName,
    CName debugInitialContext,
    float delay,
    ent.EntityID answeringEntityID,
    bool canPlayInVehicle
);

static void PlaySound(game.Object self, CName eventName, CName emitterName) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::PlaySound;GameObjectCNameCName",
    (Object_PlaySound x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_PlaySound(
    game.Object? self,
    CName eventName,
    CName emitterName
);

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

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::TagObject;GameObject",
    (Object_TagObject x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static float GetFinisherHealthThresholdIncrease(WeakHandle<game.Object> target, WeakHandle<game.Object> playerPuppet) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameObject",
    "gameObject::GetFinisherHealthThresholdIncrease;GameObjectGameObject",
    (Object_GetFinisherHealthThresholdIncrease x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

static int GetTargetAngleInInt(game.Object target, game.Object owner) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameObject",
    "gameObject::GetTargetAngleInInt;GameObjectGameObject",
    (Object_GetTargetAngleInInt2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

static float GetAttackAngleInFloat(game.events.HitEvent hitEvent) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameObject",
    "gameObject::GetAttackAngleInFloat;gameHitEvent",
    (Object_GetAttackAngleInFloat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetAttackAngleInFloat(
    game.events.HitEvent? hitEvent
);

static int GetLocalAngleForDirectionInInt(Vector4 direction, game.Object owner) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameObject",
    "gameObject::GetLocalAngleForDirectionInInt;Vector4GameObject",
    (Object_GetLocalAngleForDirectionInInt x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetLocalAngleForDirectionInInt(
    Vector4 direction,
    game.Object? owner
);

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

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::RemoveListener;GameObjectGameObjectListener",
    (Object_RemoveListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static void PlaySoundWithParams(game.Object self, CName eventName, CName emitterName, audio.AudioEventFlags flag, audio.EventActionType type)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::PlaySoundWithParams;GameObjectCNameCNameaudioAudioEventFlagsaudioEventActionType",
    (Object_PlaySoundWithParams x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_PlaySoundWithParams(
    game.Object? self,
    CName eventName,
    CName emitterName,
    audio.AudioEventFlags flag,
    audio.EventActionType type
);

static void StartReplicatedEffectEvent(game.Object self, CName effectName, bool shouldPersist, bool breakAllOnDestroy) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameObject",
    "gameObject::StartReplicatedEffectEvent;GameObjectCNameBoolBool",
    (Object_StartReplicatedEffectEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_StartReplicatedEffectEvent(
    game.Object? self,
    CName effectName,
    bool shouldPersist,
    bool breakAllOnDestroy
);