class

Door

45 properties
111 functions
3 derived classes

Extends InteractiveDevice Device game.DeviceBase game.Object ent.GameEntity ent.Entity IScriptable ISerializable

Derived

Properties

Property	Type	Offset
`animationController`	`ent.AnimationControllerComponent?`	`0x3D0`	scripted
`triggerComponent`	`game.StaticTriggerAreaComponent?`	`0x3E0`	scripted
`triggerSideOne`	`game.StaticTriggerAreaComponent?`	`0x3F0`	scripted
`triggerSideTwo`	`game.StaticTriggerAreaComponent?`	`0x400`	scripted
`offMeshConnectionComponent`	`AIOffMeshConnectionComponent?`	`0x410`	scripted
`strongSoloFrame`	`ent.MeshComponent?`	`0x420`	scripted
`terminalNetrunner1`	`ent.MeshComponent?`	`0x430`	scripted
`terminalNetrunner2`	`ent.MeshComponent?`	`0x440`	scripted
`terminalTechie1`	`ent.MeshComponent?`	`0x450`	scripted
`terminalTechie2`	`ent.MeshComponent?`	`0x460`	scripted
`ledTechie1`	`game.LightComponent?`	`0x470`	scripted
`ledTechie2`	`game.LightComponent?`	`0x480`	scripted
`ledNetrunner1`	`game.LightComponent?`	`0x490`	scripted
`ledNetrunner2`	`game.LightComponent?`	`0x4A0`	scripted
`led1`	`game.LightComponent?`	`0x4B0`	scripted
`led2`	`game.LightComponent?`	`0x4C0`	scripted
`ledHandle1`	`game.LightComponent?`	`0x4D0`	scripted
`ledHandle2`	`game.LightComponent?`	`0x4E0`	scripted
`ledHandle1a`	`game.LightComponent?`	`0x4F0`	scripted
`ledHandle2a`	`game.LightComponent?`	`0x500`	scripted
`occluder`	`ent.IPlacedComponent?`	`0x510`	scripted
`portalLight1`	`game.LightComponent?`	`0x520`	scripted
`portalLight2`	`game.LightComponent?`	`0x530`	scripted
`portalLight3`	`game.LightComponent?`	`0x540`	scripted
`portalLight4`	`game.LightComponent?`	`0x550`	scripted
`playerBlocker`	`ent.ColliderComponent?`	`0x560`	scripted
`animFeatureDoor`	`AnimFeatureDoor?`	`0x570`	scripted
`isVisuallyOpened`	`bool`	`0x580`	scripted
`lastDoorSide`	`int`	`0x584`	scripted
`colors`	`LedColors`	`0x588`	scripted
`activeSkillcheckLights`	`game.LightComponent?[]`	`0x5A0`	scripted
`allActiveLights`	`game.LightComponent?[]`	`0x5B0`	scripted
`closingAnimationLength`	`float`	`0x5C0`	scripted
`automaticCloseDelay`	`float`	`0x5C4`	scripted
`doorOpeningType`	`EDoorOpeningType`	`0x5C8`	scripted
`forceOpeningAudioStimRange`	`float`	`0x5CC`	scripted
`openingAudioStimRange`	`float`	`0x5D0`	scripted
`animationType`	`EAnimationType`	`0x5D4`	scripted
`doorTriggerSide`	`EDoorTriggerSide`	`0x5D8`	scripted
`whoOpened`	`WeakHandle<game.Object>`	`0x5E0`	scripted
`openedUsingForce`	`bool`	`0x5F0`	scripted
`illegalOpen`	`bool`	`0x5F1`	scripted
`audioForceOpen`	`bool`	`0x5F2`	scripted
`componentName`	`CName`	`0x5F8`	scripted
`playerInWorkspot`	`WeakHandle<PlayerPuppet>`	`0x600`	scripted

Functions

void UpdateLightByTask() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "UpdateLightByTask;",
    (Door_UpdateLightByTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_UpdateLightByTask(
    Door self
);

void UpdateLightTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "UpdateLightTask;ScriptTaskData",
    (Door_UpdateLightTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void SetAppearance() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "SetAppearance;",
    (Door_SetAppearance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_SetAppearance(
    Door self
);

void SetAppearanceTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "SetAppearanceTask;ScriptTaskData",
    (Door_SetAppearanceTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void EvaluateOffMeshLinks() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "EvaluateOffMeshLinks;",
    (Door_EvaluateOffMeshLinks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_EvaluateOffMeshLinks(
    Door self
);

void EvaluateOffMeshLinksTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "EvaluateOffMeshLinksTask;ScriptTaskData",
    (Door_EvaluateOffMeshLinksTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

CName GetDeviceStateClass() overrideRTTI

Generated hook

re.Hooks.Place(
    "Door",
    "GetDeviceStateClass;",
    (Door_GetDeviceStateClass x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_GetDeviceStateClass(
    Door self
);

bool OnRequestComponents(ent.EntityRequestComponentsInterface ri) overrideRTTI

Generated hook

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

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

void OnMaraudersMapDeviceDebug(world.MaraudersMapDevicesSink sink) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "OnMaraudersMapDeviceDebug;MaraudersMapDevicesSink",
    (Door_OnMaraudersMapDeviceDebug x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnMaraudersMapDeviceDebug(
    Door self,
    world.MaraudersMapDevicesSink? sink
);

bool OnTakeControl(ent.EntityResolveComponentsInterface ri) overrideRTTI

Generated hook

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

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

bool OnGameAttached() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Door_OnGameAttached(
    Door self
);

void ResolveGameplayState() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "ResolveGameplayState;",
    (Door_ResolveGameplayState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_ResolveGameplayState(
    Door self
);

void ResolveIllegalAction(game.Object executor, float duration) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "ResolveIllegalAction;GameObjectFloat",
    (Door_ResolveIllegalAction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_ResolveIllegalAction(
    Door self,
    game.Object? executor,
    float duration
);

bool OnDetach() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Door_OnDetach(
    Door self
);

DoorControllerPS? GetDevicePS() overrideRTTI

Generated hook

re.Hooks.Place(
    "Door",
    "GetDevicePS;",
    (Door_GetDevicePS x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.DoorControllerPS>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_GetDevicePS(
    Door self
);

DoorController? GetController() overrideRTTI

Generated hook

re.Hooks.Place(
    "Door",
    "GetController;",
    (Door_GetController x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.DoorController>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_GetController(
    Door self
);

bool OnPersitentStateInitialized(GameAttachedEvent evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnPersitentStateInitialized",
    (Door_OnPersitentStateInitialized x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnPersitentStateInitialized(
    Door self,
    GameAttachedEvent? evt
);

void UpdateLight() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "UpdateLight;",
    (Door_UpdateLight x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_UpdateLight(
    Door self
);

bool RedLightCondition() RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "RedLightCondition;",
    (Door_RedLightCondition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_RedLightCondition(
    Door self
);

void TurnLightsOff() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "TurnLightsOff;",
    (Door_TurnLightsOff x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_TurnLightsOff(
    Door self
);

void SetColor(ScriptLightSettings lightSettings) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "SetColor;ScriptLightSettings",
    (Door_SetColor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_SetColor(
    Door self,
    ScriptLightSettings lightSettings
);

bool OnChangeHalfLights(ChangeHalfLights evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnChangeHalfLights",
    (Door_OnChangeHalfLights x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnChangeHalfLights(
    Door self,
    ChangeHalfLights? evt
);

void ChangeHalfLights() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "ChangeHalfLights;",
    (Door_ChangeHalfLights x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_ChangeHalfLights(
    Door self
);

bool UpdateDeviceState(bool? isDelayed) overrideRTTI

Generated hook

re.Hooks.Place(
    "Door",
    "UpdateDeviceState;Bool",
    (Door_UpdateDeviceState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_UpdateDeviceState(
    Door self,
    bool? isDelayed
);

void RestoreDeviceState() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "RestoreDeviceState;",
    (Door_RestoreDeviceState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_RestoreDeviceState(
    Door self
);

void ApplyReplicatedState(game.DeviceReplicatedState state) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "ApplyReplicatedState;DeviceReplicatedState",
    (Door_ApplyReplicatedState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_ApplyReplicatedState(
    Door self,
    game.DeviceReplicatedState? state
);

void AccessGrantedNotification() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "AccessGrantedNotification;",
    (Door_AccessGrantedNotification x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_AccessGrantedNotification(
    Door self
);

bool OnPay(Pay evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnPay",
    (Door_OnPay x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnPay(
    Door self,
    Pay? evt
);

void DeactivateDevice() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "DeactivateDevice;",
    (Door_DeactivateDevice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_DeactivateDevice(
    Door self
);

void ActivateDevice() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "ActivateDevice;",
    (Door_ActivateDevice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_ActivateDevice(
    Door self
);

bool OnAreaEnter(ent.AreaEnteredEvent evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnAreaEnter",
    (Door_OnAreaEnter x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnAreaEnter(
    Door self,
    ent.AreaEnteredEvent? evt
);

bool OnAreaExit(ent.AreaExitedEvent evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnAreaExit",
    (Door_OnAreaExit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnAreaExit(
    Door self,
    ent.AreaExitedEvent? evt
);

bool IsPlayerInsideLift() RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "IsPlayerInsideLift;",
    (Door_IsPlayerInsideLift x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_IsPlayerInsideLift(
    Door self
);

bool OnApproachingAreaResponseEvent(AIApproachingAreaResponseEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnApproachingAreaResponseEvent",
    (Door_OnApproachingAreaResponseEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnApproachingAreaResponseEvent(
    Door self,
    AIApproachingAreaResponseEvent? evt
);

game.GetActionsContext GenerateInternalContext(game.Object? activator) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "GenerateInternalContext;GameObject",
    (Door_GenerateInternalContext x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GetActionsContext>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_GenerateInternalContext(
    Door self,
    game.Object? activator
);

bool HasValidOpeningToken(ent.EntityID id) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "HasValidOpeningToken;EntityID",
    (Door_HasValidOpeningToken x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_HasValidOpeningToken(
    Door self,
    ent.EntityID id
);

bool OnDoorTriggerDelayedEvent(DoorTriggerDelayedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnDoorTriggerDelayedEvent",
    (Door_OnDoorTriggerDelayedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnDoorTriggerDelayedEvent(
    Door self,
    DoorTriggerDelayedEvent? evt
);

bool IsSomeoneAuthorizedNearby() RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "IsSomeoneAuthorizedNearby;",
    (Door_IsSomeoneAuthorizedNearby x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_IsSomeoneAuthorizedNearby(
    Door self
);

game.Object? ClosestAuthorizedActiveEntityNearby() RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "ClosestAuthorizedActiveEntityNearby;",
    (Door_ClosestAuthorizedActiveEntityNearby x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_ClosestAuthorizedActiveEntityNearby(
    Door self
);

bool OnAuthorizeUser(AuthorizeUser evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnAuthorizeUser",
    (Door_OnAuthorizeUser x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnAuthorizeUser(
    Door self,
    AuthorizeUser? evt
);

bool IsSomeoneInTrigger() RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "IsSomeoneInTrigger;",
    (Door_IsSomeoneInTrigger x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_IsSomeoneInTrigger(
    Door self
);

bool OnForceUnlockAndOpenElevator(ForceUnlockAndOpenElevator evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnForceUnlockAndOpenElevator",
    (Door_OnForceUnlockAndOpenElevator x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnForceUnlockAndOpenElevator(
    Door self,
    ForceUnlockAndOpenElevator? evt
);

bool OnToggleOpen(ToggleOpen evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnToggleOpen",
    (Door_OnToggleOpen x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnToggleOpen(
    Door self,
    ToggleOpen? evt
);

bool OnActionDemolition(ActionDemolition evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnActionDemolition",
    (Door_OnActionDemolition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnActionDemolition(
    Door self,
    ActionDemolition? evt
);

bool OnActionEngineering(ActionEngineering evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnActionEngineering",
    (Door_OnActionEngineering x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnActionEngineering(
    Door self,
    ActionEngineering? evt
);

bool OnToggleLock(ToggleLock evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnToggleLock",
    (Door_OnToggleLock x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnToggleLock(
    Door self,
    ToggleLock? evt
);

bool OnQuestForceUnlock(QuestForceUnlock evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnQuestForceUnlock",
    (Door_OnQuestForceUnlock x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnQuestForceUnlock(
    Door self,
    QuestForceUnlock? evt
);

bool OnQuestForceUnseal(QuestForceUnseal evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnQuestForceUnseal",
    (Door_OnQuestForceUnseal x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnQuestForceUnseal(
    Door self,
    QuestForceUnseal? evt
);

bool OnSealDoor(ToggleSeal evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnSealDoor",
    (Door_OnSealDoor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnSealDoor(
    Door self,
    ToggleSeal? evt
);

bool OnDoorOpeningToken(DoorOpeningToken evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnDoorOpeningToken",
    (Door_OnDoorOpeningToken x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnDoorOpeningToken(
    Door self,
    DoorOpeningToken? evt
);

bool OnSetAuthorizationModuleOFF(SetAuthorizationModuleOFF evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnSetAuthorizationModuleOFF",
    (Door_OnSetAuthorizationModuleOFF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnSetAuthorizationModuleOFF(
    Door self,
    SetAuthorizationModuleOFF? evt
);

bool OnActivateDevice(ActivateDevice evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnActivateDevice",
    (Door_OnActivateDevice x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnActivateDevice(
    Door self,
    ActivateDevice? evt
);

bool OnForceOpen(ForceOpen evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnForceOpen",
    (Door_OnForceOpen x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnForceOpen(
    Door self,
    ForceOpen? evt
);

bool OnQuestForceClose(QuestForceClose evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnQuestForceClose",
    (Door_OnQuestForceClose x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnQuestForceClose(
    Door self,
    QuestForceClose? evt
);

bool OnQuestForceCloseImmediate(QuestForceCloseImmediate evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnQuestForceCloseImmediate",
    (Door_OnQuestForceCloseImmediate x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnQuestForceCloseImmediate(
    Door self,
    QuestForceCloseImmediate? evt
);

void EnablePlayerBlocker() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "EnablePlayerBlocker;",
    (Door_EnablePlayerBlocker x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_EnablePlayerBlocker(
    Door self
);

void DisablePlayerBlocker() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "DisablePlayerBlocker;",
    (Door_DisablePlayerBlocker x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_DisablePlayerBlocker(
    Door self
);

bool OnQuestForceOpenScene(QuestForceOpenScene evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnQuestForceOpenScene",
    (Door_OnQuestForceOpenScene x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnQuestForceOpenScene(
    Door self,
    QuestForceOpenScene? evt
);

bool OnQuestForceCloseScene(QuestForceCloseScene evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnQuestForceCloseScene",
    (Door_OnQuestForceCloseScene x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnQuestForceCloseScene(
    Door self,
    QuestForceCloseScene? evt
);

bool OnQuestForceEnabled(QuestForceEnabled evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnQuestForceEnabled",
    (Door_OnQuestForceEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnQuestForceEnabled(
    Door self,
    QuestForceEnabled? evt
);

void ToggleDoorOpeningState(ent.EntityID? forWhom) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "ToggleDoorOpeningState;EntityID",
    (Door_ToggleDoorOpeningState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_ToggleDoorOpeningState(
    Door self,
    ent.EntityID? forWhom
);

void ToggleDoorOpeningState(game.Object activator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "ToggleDoorOpeningState;GameObject",
    (Door_ToggleDoorOpeningState2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_ToggleDoorOpeningState2(
    Door self,
    game.Object? activator
);

void OpenDoor() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "OpenDoor;",
    (Door_OpenDoor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OpenDoor(
    Door self
);

void CloseDoor() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "CloseDoor;",
    (Door_CloseDoor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_CloseDoor(
    Door self
);

void ToggleDoorLockState(game.Object activator, bool shouldOpen) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "ToggleDoorLockState;GameObjectBool",
    (Door_ToggleDoorLockState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_ToggleDoorLockState(
    Door self,
    game.Object? activator,
    bool shouldOpen
);

bool OnCollision(ent.events.HitCharacterControllerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnCollision",
    (Door_OnCollision x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnCollision(
    Door self,
    ent.events.HitCharacterControllerEvent? evt
);

bool MoveDoor(bool shouldBeOpened, bool immediate, float? movingSpeedMultiplier) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "MoveDoor;BoolBoolFloat",
    (Door_MoveDoor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_MoveDoor(
    Door self,
    bool shouldBeOpened,
    bool immediate,
    float? movingSpeedMultiplier
);

void TriggerMoveDoorStimBroadcaster(StimBroadcasterComponent broadcaster, sense.StimInvestigateData reactionData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "TriggerMoveDoorStimBroadcaster;StimBroadcasterComponentstimInvestigateData",
    (Door_TriggerMoveDoorStimBroadcaster x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_TriggerMoveDoorStimBroadcaster(
    Door self,
    StimBroadcasterComponent? broadcaster,
    sense.StimInvestigateData reactionData
);

float GetOpeningTime() RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "GetOpeningTime;",
    (Door_GetOpeningTime x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_GetOpeningTime(
    Door self
);

bool OnSetBusyEvent(SetBusyEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnSetBusyEvent",
    (Door_OnSetBusyEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnSetBusyEvent(
    Door self,
    SetBusyEvent? evt
);

void DisableOccluder() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "DisableOccluder;",
    (Door_DisableOccluder x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_DisableOccluder(
    Door self
);

void EnableOccluderWithDelay(float delay) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "EnableOccluderWithDelay;Float",
    (Door_EnableOccluderWithDelay x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_EnableOccluderWithDelay(
    Door self,
    float delay
);

void EnableOccluderInstanly() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "EnableOccluderInstanly;",
    (Door_EnableOccluderInstanly x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_EnableOccluderInstanly(
    Door self
);

bool OnOccluderEnable(OccluderEnableEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnOccluderEnable",
    (Door_OnOccluderEnable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnOccluderEnable(
    Door self,
    OccluderEnableEvent? evt
);

void UpdatePortalLights(bool on) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "UpdatePortalLights;Bool",
    (Door_UpdatePortalLights x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_UpdatePortalLights(
    Door self,
    bool on
);

void EnterWorkspot(game.Object activator, bool? freeCamera, CName? componentName, CName? deviceData) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "EnterWorkspot;GameObjectBoolCNameCName",
    (Door_EnterWorkspot x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_EnterWorkspot(
    Door self,
    game.Object? activator,
    bool? freeCamera,
    CName? componentName,
    CName? deviceData
);

bool OnPlayInDeviceCallbackEvent(game.PlayInDeviceCallbackEvent evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnPlayInDeviceCallbackEvent",
    (Door_OnPlayInDeviceCallbackEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnPlayInDeviceCallbackEvent(
    Door self,
    game.PlayInDeviceCallbackEvent? evt
);

bool OnWorkspotFinished(CName componentName) overrideRTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnWorkspotFinished",
    (Door_OnWorkspotFinished x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnWorkspotFinished(
    Door self,
    CName componentName
);

void SetIsDoorInteractionActiveBB(game.interactions.InteractionActivationEvent evt, bool isActive) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "SetIsDoorInteractionActiveBB;InteractionActivationEventBool",
    (Door_SetIsDoorInteractionActiveBB x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_SetIsDoorInteractionActiveBB(
    Door self,
    game.interactions.InteractionActivationEvent? evt,
    bool isActive
);

void PlayLockSound(bool toLock) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "PlayLockSound;Bool",
    (Door_PlayLockSound x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_PlayLockSound(
    Door self,
    bool toLock
);

void PlayDoorSealSound(bool toSeal) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "PlayDoorSealSound;Bool",
    (Door_PlayDoorSealSound x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_PlayDoorSealSound(
    Door self,
    bool toSeal
);

void PlayDoorMovementSound(bool shouldBeOpened, bool wasOpenedUsingForce) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "PlayDoorMovementSound;BoolBool",
    (Door_PlayDoorMovementSound x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_PlayDoorMovementSound(
    Door self,
    bool shouldBeOpened,
    bool wasOpenedUsingForce
);

void PlayOpenDoorSound() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "PlayOpenDoorSound;",
    (Door_PlayOpenDoorSound x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_PlayOpenDoorSound(
    Door self
);

void ExecuteDeviceStateOperation() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "ExecuteDeviceStateOperation;",
    (Door_ExecuteDeviceStateOperation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_ExecuteDeviceStateOperation(
    Door self
);

void RefreshAnimOpenDoor(bool shouldBeOpened, bool immediate, float animSpeedMultiplier) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "RefreshAnimOpenDoor;BoolBoolFloat",
    (Door_RefreshAnimOpenDoor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_RefreshAnimOpenDoor(
    Door self,
    bool shouldBeOpened,
    bool immediate,
    float animSpeedMultiplier
);

void SetupOpenDoorAnimationFeatures() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "SetupOpenDoorAnimationFeatures;",
    (Door_SetupOpenDoorAnimationFeatures x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_SetupOpenDoorAnimationFeatures(
    Door self
);

float GetOpeningSpeed() RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "GetOpeningSpeed;",
    (Door_GetOpeningSpeed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_GetOpeningSpeed(
    Door self
);

void RefreshTransformAnimOpenDoor(bool shouldBeOpened, bool immediate, float animSpeedMultiplier) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "RefreshTransformAnimOpenDoor;BoolBoolFloat",
    (Door_RefreshTransformAnimOpenDoor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_RefreshTransformAnimOpenDoor(
    Door self,
    bool shouldBeOpened,
    bool immediate,
    float animSpeedMultiplier
);

CName GetProperTransformAnimName() RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "GetProperTransformAnimName;",
    (Door_GetProperTransformAnimName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_GetProperTransformAnimName(
    Door self
);

void SetNewDoorType(EDoorType type) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "SetNewDoorType;EDoorType",
    (Door_SetNewDoorType x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_SetNewDoorType(
    Door self,
    EDoorType type
);

bool OnSetDoorType(SetDoorType evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnSetDoorType",
    (Door_OnSetDoorType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnSetDoorType(
    Door self,
    SetDoorType? evt
);

bool OnSetCloseItself(SetCloseItself evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnSetCloseItself",
    (Door_OnSetCloseItself x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnSetCloseItself(
    Door self,
    SetCloseItself? evt
);

bool OnResetDoorState(ResetDoorState evt) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "OnResetDoorState",
    (Door_OnResetDoorState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_OnResetDoorState(
    Door self,
    ResetDoorState? evt
);

EDoorTriggerSide GetDoorTriggerSide(ent.Entity forEntity) RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "GetDoorTriggerSide;Entity",
    (Door_GetDoorTriggerSide x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EDoorTriggerSide>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_GetDoorTriggerSide(
    Door self,
    ent.Entity? forEntity
);

ent.Entity? GetPlayerEntity() RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "GetPlayerEntity;",
    (Door_GetPlayerEntity x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.Entity>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_GetPlayerEntity(
    Door self
);

void CreateLightSettings() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "CreateLightSettings;",
    (Door_CreateLightSettings x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_CreateLightSettings(
    Door self
);

void SetSoloAppearance() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "SetSoloAppearance;",
    (Door_SetSoloAppearance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_SetSoloAppearance(
    Door self
);

void SetTechieAppearance() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "SetTechieAppearance;",
    (Door_SetTechieAppearance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_SetTechieAppearance(
    Door self
);

void SetNetrunnerAppearance() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "SetNetrunnerAppearance;",
    (Door_SetNetrunnerAppearance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_SetNetrunnerAppearance(
    Door self
);

void InitializeLight() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "InitializeLight;",
    (Door_InitializeLight x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_InitializeLight(
    Door self
);

void GetAllActiveLights() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Door",
    "GetAllActiveLights;",
    (Door_GetAllActiveLights x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_GetAllActiveLights(
    Door self
);

EGameplayRole DeterminGameplayRole() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Door_DeterminGameplayRole(
    Door self
);

EMappinVisualState DeterminGameplayRoleMappinVisuaState(SDeviceMappinData data) overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Door_DeterminGameplayRoleMappinVisuaState(
    Door self,
    SDeviceMappinData data
);

bool IsActive() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Door_IsActive(
    Door self
);

void EnableOffMeshConnections(bool player, bool npc) overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Door_EnableOffMeshConnections(
    Door self,
    bool player,
    bool npc
);

void DisableOffMeshConnections(bool player, bool npc) overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Door_DisableOffMeshConnections(
    Door self,
    bool player,
    bool npc
);

bool CanPassAnySkillCheckOnParentTerminal() RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "CanPassAnySkillCheckOnParentTerminal;",
    (Door_CanPassAnySkillCheckOnParentTerminal x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_CanPassAnySkillCheckOnParentTerminal(
    Door self
);

float GetClosingAnimationLength() RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "GetClosingAnimationLength;",
    (Door_GetClosingAnimationLength x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_GetClosingAnimationLength(
    Door self
);

AnimFeatureDoor? GetAnimFeature() RTTI

Generated hook

re.Hooks.Place(
    "Door",
    "GetAnimFeature;",
    (Door_GetAnimFeature x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.AnimFeatureDoor>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Door_GetAnimFeature(
    Door self
);

bool IsNetrunner() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Door_IsNetrunner(
    Door self
);

bool HasAnyDirectInteractionActive() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Door_HasAnyDirectInteractionActive(
    Door self
);