class

TakeOverControlSystem

14 properties
50 functions

Extends game.ScriptableSystem game.IScriptableSystem IScriptable ISerializable

Properties

Property	Type	Offset
`controlledObject`	`WeakHandle<game.Object>`	`0x0`	scripted
`takeControlSourceID`	`ent.EntityID`	`0x10`	scripted
`isInputRegistered`	`bool`	`0x18`	scripted
`isInputLockedFromQuest`	`bool`	`0x19`	scripted
`isChainForcedFromQuest`	`bool`	`0x1A`	scripted
`isActionButtonLocked`	`bool`	`0x1B`	scripted
`isDeviceChainCreationLocked`	`bool`	`0x1C`	scripted
`isReleaseOnHitLocked`	`bool`	`0x1D`	scripted
`chainLockSources`	`CName[]`	`0x20`	scripted
`TCDUpdateDelayID`	`game.DelayID`	`0x30`	scripted
`TCSupdateRate`	`float`	`0x38`	scripted
`lastInputSimTime`	`float`	`0x3C`	scripted
`sniperNestObject`	`WeakHandle<game.Object>`	`0x40`	scripted
`timestampLastTCS`	`float`	`0x50`	scripted

Functions

game.Object? GetControlledObject() RTTI

Generated hook

re.Hooks.Place(
    "TakeOverControlSystem",
    "GetControlledObject;",
    (TakeOverControlSystem_GetControlledObject x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_GetControlledObject(
    TakeOverControlSystem self
);

bool IsInputLockedFromQuest() RTTI

Generated hook

re.Hooks.Place(
    "TakeOverControlSystem",
    "IsInputLockedFromQuest;",
    (TakeOverControlSystem_IsInputLockedFromQuest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_IsInputLockedFromQuest(
    TakeOverControlSystem self
);

bool IsDeviceControlled() RTTI

Generated hook

re.Hooks.Place(
    "TakeOverControlSystem",
    "IsDeviceControlled;",
    (TakeOverControlSystem_IsDeviceControlled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_IsDeviceControlled(
    TakeOverControlSystem self
);

bool IsSavingLocked() overrideRTTI

Generated hook

re.Hooks.Place(
    "TakeOverControlSystem",
    "IsSavingLocked;",
    (TakeOverControlSystem_IsSavingLocked x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_IsSavingLocked(
    TakeOverControlSystem self
);

void CleanupControlledObject() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "CleanupControlledObject;",
    (TakeOverControlSystem_CleanupControlledObject x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_CleanupControlledObject(
    TakeOverControlSystem self
);

void OnLockTakeControlActionRequest(LockTakeControlAction request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "OnLockTakeControlActionRequest;LockTakeControlAction",
    (TakeOverControlSystem_OnLockTakeControlActionRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_OnLockTakeControlActionRequest(
    TakeOverControlSystem self,
    LockTakeControlAction? request
);

void OnLockReleaseOnHitRequest(LockReleaseOnHit request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "OnLockReleaseOnHitRequest;LockReleaseOnHit",
    (TakeOverControlSystem_OnLockReleaseOnHitRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_OnLockReleaseOnHitRequest(
    TakeOverControlSystem self,
    LockReleaseOnHit? request
);

void OnLockDeviceChainCreationRequest(LockDeviceChainCreation request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "OnLockDeviceChainCreationRequest;LockDeviceChainCreation",
    (TakeOverControlSystem_OnLockDeviceChainCreationRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_OnLockDeviceChainCreationRequest(
    TakeOverControlSystem self,
    LockDeviceChainCreation? request
);

bool IsDeviceChainCreationLocked() RTTI

Generated hook

re.Hooks.Place(
    "TakeOverControlSystem",
    "IsDeviceChainCreationLocked;",
    (TakeOverControlSystem_IsDeviceChainCreationLocked x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_IsDeviceChainCreationLocked(
    TakeOverControlSystem self
);

void LockInputFromQuestRequest(bool isLocked) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "LockInputFromQuestRequest;Bool",
    (TakeOverControlSystem_LockInputFromQuestRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_LockInputFromQuestRequest(
    TakeOverControlSystem self,
    bool isLocked
);

void ForceChainFromQuestRequest(bool isChainForced) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "ForceChainFromQuestRequest;Bool",
    (TakeOverControlSystem_ForceChainFromQuestRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_ForceChainFromQuestRequest(
    TakeOverControlSystem self,
    bool isChainForced
);

void OnRequestTakeControl(RequestTakeControl request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "OnRequestTakeControl;RequestTakeControl",
    (TakeOverControlSystem_OnRequestTakeControl x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_OnRequestTakeControl(
    TakeOverControlSystem self,
    RequestTakeControl? request
);

void OnRemoveFromChainRequest(RemoveFromChainRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "OnRemoveFromChainRequest;RemoveFromChainRequest",
    (TakeOverControlSystem_OnRemoveFromChainRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_OnRemoveFromChainRequest(
    TakeOverControlSystem self,
    RemoveFromChainRequest? request
);

void OnRequestReleaseControl(RequestReleaseControl request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "OnRequestReleaseControl;RequestReleaseControl",
    (TakeOverControlSystem_OnRequestReleaseControl x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_OnRequestReleaseControl(
    TakeOverControlSystem self,
    RequestReleaseControl? request
);

void OnRequestQuestTakeControlInputLock(RequestQuestTakeControlInputLock request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "OnRequestQuestTakeControlInputLock;RequestQuestTakeControlInputLock",
    (TakeOverControlSystem_OnRequestQuestTakeControlInputLock x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_OnRequestQuestTakeControlInputLock(
    TakeOverControlSystem self,
    RequestQuestTakeControlInputLock? request
);

void ReleaseCurrentObject() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "ReleaseCurrentObject;",
    (TakeOverControlSystem_ReleaseCurrentObject x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_ReleaseCurrentObject(
    TakeOverControlSystem self
);

void RegisterAsCurrentObject(ent.EntityID entityID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "RegisterAsCurrentObject;EntityID",
    (TakeOverControlSystem_RegisterAsCurrentObject x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_RegisterAsCurrentObject(
    TakeOverControlSystem self,
    ent.EntityID entityID
);

void RegisterBBActiveObjectAsCurrentObject() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "RegisterBBActiveObjectAsCurrentObject;",
    (TakeOverControlSystem_RegisterBBActiveObjectAsCurrentObject x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_RegisterBBActiveObjectAsCurrentObject(
    TakeOverControlSystem self
);

void RegisterObjectHandle(ent.EntityID EntID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "RegisterObjectHandle;EntityID",
    (TakeOverControlSystem_RegisterObjectHandle x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_RegisterObjectHandle(
    TakeOverControlSystem self,
    ent.EntityID EntID
);

void SendTSCActivateEventToEntity(bool isQuickhack) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "SendTSCActivateEventToEntity;Bool",
    (TakeOverControlSystem_SendTSCActivateEventToEntity x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_SendTSCActivateEventToEntity(
    TakeOverControlSystem self,
    bool isQuickhack
);

void GetCameraDataFromControlledObject(game.Object ent, game.Object player) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "GetCameraDataFromControlledObject;GameObjectGameObject",
    (TakeOverControlSystem_GetCameraDataFromControlledObject x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_GetCameraDataFromControlledObject(
    TakeOverControlSystem self,
    game.Object? ent,
    game.Object? player
);

SWidgetPackage[] GetChain() RTTI

void TryFillControlBlackboard(RequestTakeControl evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "TryFillControlBlackboard;RequestTakeControl",
    (TakeOverControlSystem_TryFillControlBlackboard x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_TryFillControlBlackboard(
    TakeOverControlSystem self,
    RequestTakeControl? evt
);

void TryFillControlBlackboardByForce(RequestTakeControl evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "TryFillControlBlackboardByForce;RequestTakeControl",
    (TakeOverControlSystem_TryFillControlBlackboardByForce x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_TryFillControlBlackboardByForce(
    TakeOverControlSystem self,
    RequestTakeControl? evt
);

void RegisterSystemOnInput(bool register) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "RegisterSystemOnInput;Bool",
    (TakeOverControlSystem_RegisterSystemOnInput x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_RegisterSystemOnInput(
    TakeOverControlSystem self,
    bool register
);

void ShowChainControls(bool show) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "ShowChainControls;Bool",
    (TakeOverControlSystem_ShowChainControls x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_ShowChainControls(
    TakeOverControlSystem self,
    bool show
);

void PSMSetIsPlayerControllDevice(bool controllsDevice) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "PSMSetIsPlayerControllDevice;Bool",
    (TakeOverControlSystem_PSMSetIsPlayerControllDevice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_PSMSetIsPlayerControllDevice(
    TakeOverControlSystem self,
    bool controllsDevice
);

void ToggleToNextControlledDevice() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "ToggleToNextControlledDevice;",
    (TakeOverControlSystem_ToggleToNextControlledDevice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_ToggleToNextControlledDevice(
    TakeOverControlSystem self
);

void ToggleToPreviousControlledDevice() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "ToggleToPreviousControlledDevice;",
    (TakeOverControlSystem_ToggleToPreviousControlledDevice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_ToggleToPreviousControlledDevice(
    TakeOverControlSystem self
);

void ToggleToOtherDeviceFromChain(SWidgetPackage otherPackage) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "ToggleToOtherDeviceFromChain;script_ref<SWidgetPackage>",
    (TakeOverControlSystem_ToggleToOtherDeviceFromChain x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_ToggleToOtherDeviceFromChain(
    TakeOverControlSystem self,
    SWidgetPackage otherPackage
);

void ToggleToMainPlayerObject() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "ToggleToMainPlayerObject;",
    (TakeOverControlSystem_ToggleToMainPlayerObject x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_ToggleToMainPlayerObject(
    TakeOverControlSystem self
);

void ReturnToDeviceScreen() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "ReturnToDeviceScreen;",
    (TakeOverControlSystem_ReturnToDeviceScreen x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_ReturnToDeviceScreen(
    TakeOverControlSystem self
);

SWidgetPackage GetPackageFromChainNextToMe(bool higher, out bool isValid) RTTI

Generated hook

re.Hooks.Place(
    "TakeOverControlSystem",
    "GetPackageFromChainNextToMe;BoolBool",
    (TakeOverControlSystem_GetPackageFromChainNextToMe x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.SWidgetPackage>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_GetPackageFromChainNextToMe(
    TakeOverControlSystem self,
    bool higher,
    bool isValid
);

int GetCurrentActiveDeviceChainBlackboardIndex(SWidgetPackage[] deviceChain) RTTI

Generated hook

re.Hooks.Place(
    "TakeOverControlSystem",
    "GetCurrentActiveDeviceChainBlackboardIndex;script_ref<array<SWidgetPackage>>",
    (TakeOverControlSystem_GetCurrentActiveDeviceChainBlackboardIndex x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_GetCurrentActiveDeviceChainBlackboardIndex(
    TakeOverControlSystem self,
    SWidgetPackage[] deviceChain
);

void MoveToSpecificEntity(ent.EntityID entity) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "MoveToSpecificEntity;EntityID",
    (TakeOverControlSystem_MoveToSpecificEntity x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_MoveToSpecificEntity(
    TakeOverControlSystem self,
    ent.EntityID entity
);

void EnablePlayerTPPRepresenation(bool enable) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "EnablePlayerTPPRepresenation;Bool",
    (TakeOverControlSystem_EnablePlayerTPPRepresenation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void CleanupChainBlackboard() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "CleanupChainBlackboard;",
    (TakeOverControlSystem_CleanupChainBlackboard x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_CleanupChainBlackboard(
    TakeOverControlSystem self
);

void CleanupActiveEntityInChainBlackboard() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "CleanupActiveEntityInChainBlackboard;",
    (TakeOverControlSystem_CleanupActiveEntityInChainBlackboard x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_CleanupActiveEntityInChainBlackboard(
    TakeOverControlSystem self
);

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

Generated hook

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

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

void HideAdvanceInteractionInputHints() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "HideAdvanceInteractionInputHints;",
    (TakeOverControlSystem_HideAdvanceInteractionInputHints x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_HideAdvanceInteractionInputHints(
    TakeOverControlSystem self
);

void CreateTCSUpdate() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "CreateTCSUpdate;",
    (TakeOverControlSystem_CreateTCSUpdate x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_CreateTCSUpdate(
    TakeOverControlSystem self
);

void BreakTCSUpdate() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "BreakTCSUpdate;",
    (TakeOverControlSystem_BreakTCSUpdate x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_BreakTCSUpdate(
    TakeOverControlSystem self
);

void OnTCSUpdate(TCSUpdate request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "OnTCSUpdate;TCSUpdate",
    (TakeOverControlSystem_OnTCSUpdate x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_OnTCSUpdate(
    TakeOverControlSystem self,
    TCSUpdate? request
);

void RefreshDebug(bool lastXYValue) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "RefreshDebug;Bool",
    (TakeOverControlSystem_RefreshDebug x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_RefreshDebug(
    TakeOverControlSystem self,
    bool lastXYValue
);

static void PlayFollowupEvent(ScriptGameInstance game, red.Event followupEvent, ent.EntityID followupEventEntityID) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "TakeOverControlSystem::PlayFollowupEvent;GameInstanceEventEntityID",
    (TakeOverControlSystem_PlayFollowupEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_PlayFollowupEvent(
    ScriptGameInstance game,
    red.Event? followupEvent,
    ent.EntityID followupEventEntityID
);

static void CreateInputHint(ScriptGameInstance context, bool isVisible) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "TakeOverControlSystem::CreateInputHint;GameInstanceBool",
    (TakeOverControlSystem_CreateInputHint x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_CreateInputHint(
    ScriptGameInstance context,
    bool isVisible
);

static void ReleaseControlOfRemoteControlledVehicle(ScriptGameInstance game, ent.EntityID playerID) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "TakeOverControlSystem::ReleaseControlOfRemoteControlledVehicle;GameInstanceEntityID",
    (TakeOverControlSystem_ReleaseControlOfRemoteControlledVehicle x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_ReleaseControlOfRemoteControlledVehicle(
    ScriptGameInstance game,
    ent.EntityID playerID
);

static bool ReleaseControl(ScriptGameInstance game, red.Event followupEvent, ent.EntityID followupEventEntityID) staticRTTI global

Generated hook

re.Hooks.Place(
    "TakeOverControlSystem",
    "TakeOverControlSystem::ReleaseControl;GameInstanceEventEntityID",
    (TakeOverControlSystem_ReleaseControl x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_ReleaseControl(
    ScriptGameInstance game,
    red.Event? followupEvent,
    ent.EntityID followupEventEntityID
);

static void RequestTakeControl(game.Object context, ToggleTakeOverControl originalevent) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "TakeOverControlSystem",
    "TakeOverControlSystem::RequestTakeControl;GameObjectToggleTakeOverControl",
    (TakeOverControlSystem_RequestTakeControl x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_RequestTakeControl(
    game.Object? context,
    ToggleTakeOverControl? originalevent
);

static bool ReleaseControlOnHit(WeakHandle<PlayerPuppet> player) staticRTTI global

Generated hook

re.Hooks.Place(
    "TakeOverControlSystem",
    "TakeOverControlSystem::ReleaseControlOnHit;PlayerPuppet",
    (TakeOverControlSystem_ReleaseControlOnHit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TakeOverControlSystem_ReleaseControlOnHit(
    WeakHandle<PlayerPuppet> player
);