class

JudysDoor

45 properties
111 functions

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

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(
    "JudysDoor",
    "UpdateLightByTask;",
    (JudysDoor_UpdateLightByTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct JudysDoor_UpdateLightByTask(
    JudysDoor self
);

void UpdateLightTask(game.ScriptTaskData data) RTTI

Generated hook

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

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

void SetAppearance() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_SetAppearance(
    JudysDoor self
);

void SetAppearanceTask(game.ScriptTaskData data) RTTI

Generated hook

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

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

void EvaluateOffMeshLinks() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_EvaluateOffMeshLinks(
    JudysDoor self
);

void EvaluateOffMeshLinksTask(game.ScriptTaskData data) RTTI

Generated hook

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

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

CName GetDeviceStateClass() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_GetDeviceStateClass(
    JudysDoor self
);

bool OnRequestComponents(ent.EntityRequestComponentsInterface ri) overrideRTTI

Generated hook

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

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

void OnMaraudersMapDeviceDebug(world.MaraudersMapDevicesSink sink) overrideRTTI

Generated hook

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

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

bool OnTakeControl(ent.EntityResolveComponentsInterface ri) overrideRTTI

Generated hook

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

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

bool OnGameAttached() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_OnGameAttached(
    JudysDoor self
);

void ResolveGameplayState() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_ResolveGameplayState(
    JudysDoor self
);

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

Generated hook

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

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

bool OnDetach() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_OnDetach(
    JudysDoor self
);

DoorControllerPS? GetDevicePS() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_GetDevicePS(
    JudysDoor self
);

DoorController? GetController() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_GetController(
    JudysDoor self
);

bool OnPersitentStateInitialized(GameAttachedEvent evt) overrideRTTI

Generated hook

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

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

void UpdateLight() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_UpdateLight(
    JudysDoor self
);

bool RedLightCondition() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_RedLightCondition(
    JudysDoor self
);

void TurnLightsOff() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_TurnLightsOff(
    JudysDoor self
);

void SetColor(ScriptLightSettings lightSettings) RTTI

Generated hook

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

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

bool OnChangeHalfLights(ChangeHalfLights evt) RTTI

Generated hook

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

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

void ChangeHalfLights() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_ChangeHalfLights(
    JudysDoor self
);

bool UpdateDeviceState(bool? isDelayed) overrideRTTI

Generated hook

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

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

void RestoreDeviceState() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_RestoreDeviceState(
    JudysDoor self
);

void ApplyReplicatedState(game.DeviceReplicatedState state) overrideRTTI

Generated hook

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

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

void AccessGrantedNotification() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_AccessGrantedNotification(
    JudysDoor self
);

bool OnPay(Pay evt) RTTI

Generated hook

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

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

void DeactivateDevice() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_DeactivateDevice(
    JudysDoor self
);

void ActivateDevice() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_ActivateDevice(
    JudysDoor self
);

bool OnAreaEnter(ent.AreaEnteredEvent evt) overrideRTTI

Generated hook

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

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

bool OnAreaExit(ent.AreaExitedEvent evt) overrideRTTI

Generated hook

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

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

bool IsPlayerInsideLift() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_IsPlayerInsideLift(
    JudysDoor self
);

bool OnApproachingAreaResponseEvent(AIApproachingAreaResponseEvent evt) RTTI

Generated hook

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

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

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

Generated hook

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

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

bool HasValidOpeningToken(ent.EntityID id) RTTI

Generated hook

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

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

bool OnDoorTriggerDelayedEvent(DoorTriggerDelayedEvent evt) RTTI

Generated hook

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

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

bool IsSomeoneAuthorizedNearby() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_IsSomeoneAuthorizedNearby(
    JudysDoor self
);

game.Object? ClosestAuthorizedActiveEntityNearby() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_ClosestAuthorizedActiveEntityNearby(
    JudysDoor self
);

bool OnAuthorizeUser(AuthorizeUser evt) overrideRTTI

Generated hook

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

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

bool IsSomeoneInTrigger() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_IsSomeoneInTrigger(
    JudysDoor self
);

bool OnForceUnlockAndOpenElevator(ForceUnlockAndOpenElevator evt) RTTI

Generated hook

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

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

bool OnToggleOpen(ToggleOpen evt) RTTI

Generated hook

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

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

bool OnActionDemolition(ActionDemolition evt) RTTI

Generated hook

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

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

bool OnActionEngineering(ActionEngineering evt) RTTI

Generated hook

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

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

bool OnToggleLock(ToggleLock evt) RTTI

Generated hook

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

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

bool OnQuestForceUnlock(QuestForceUnlock evt) RTTI

Generated hook

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

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

bool OnQuestForceUnseal(QuestForceUnseal evt) RTTI

Generated hook

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

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

bool OnSealDoor(ToggleSeal evt) RTTI

Generated hook

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

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

bool OnDoorOpeningToken(DoorOpeningToken evt) RTTI

Generated hook

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

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

bool OnSetAuthorizationModuleOFF(SetAuthorizationModuleOFF evt) overrideRTTI

Generated hook

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

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

bool OnActivateDevice(ActivateDevice evt) RTTI

Generated hook

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

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

bool OnForceOpen(ForceOpen evt) RTTI

Generated hook

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

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

bool OnQuestForceClose(QuestForceClose evt) RTTI

Generated hook

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

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

bool OnQuestForceCloseImmediate(QuestForceCloseImmediate evt) RTTI

Generated hook

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

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

void EnablePlayerBlocker() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_EnablePlayerBlocker(
    JudysDoor self
);

void DisablePlayerBlocker() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_DisablePlayerBlocker(
    JudysDoor self
);

bool OnQuestForceOpenScene(QuestForceOpenScene evt) RTTI

Generated hook

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

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

bool OnQuestForceCloseScene(QuestForceCloseScene evt) RTTI

Generated hook

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

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

bool OnQuestForceEnabled(QuestForceEnabled evt) overrideRTTI

Generated hook

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

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

void ToggleDoorOpeningState(ent.EntityID? forWhom) RTTI

Generated hook

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

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

void ToggleDoorOpeningState(game.Object activator) RTTI

Generated hook

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

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

void OpenDoor() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_OpenDoor(
    JudysDoor self
);

void CloseDoor() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_CloseDoor(
    JudysDoor self
);

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

Generated hook

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

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

bool OnCollision(ent.events.HitCharacterControllerEvent evt) RTTI

Generated hook

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

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

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

Generated hook

re.Hooks.Place(
    "JudysDoor",
    "MoveDoor;BoolBoolBoolFloat",
    (JudysDoor_MoveDoor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

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

Generated hook

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

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

float GetOpeningTime() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_GetOpeningTime(
    JudysDoor self
);

bool OnSetBusyEvent(SetBusyEvent evt) RTTI

Generated hook

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

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

void DisableOccluder() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_DisableOccluder(
    JudysDoor self
);

void EnableOccluderWithDelay(float delay) RTTI

Generated hook

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

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

void EnableOccluderInstanly() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_EnableOccluderInstanly(
    JudysDoor self
);

bool OnOccluderEnable(OccluderEnableEvent evt) RTTI

Generated hook

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

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

void UpdatePortalLights(bool on) RTTI

Generated hook

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

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

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

Generated hook

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

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

bool OnPlayInDeviceCallbackEvent(game.PlayInDeviceCallbackEvent evt) overrideRTTI

Generated hook

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

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

bool OnWorkspotFinished(CName componentName) overrideRTTI

Generated hook

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

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

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

Generated hook

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

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

void PlayLockSound(bool toLock) RTTI

Generated hook

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

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

void PlayDoorSealSound(bool toSeal) RTTI

Generated hook

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

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

void PlayDoorMovementSound(bool shouldBeOpened, bool wasOpenedUsingForce) RTTI

Generated hook

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

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

void PlayOpenDoorSound() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_PlayOpenDoorSound(
    JudysDoor self
);

void ExecuteDeviceStateOperation() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_ExecuteDeviceStateOperation(
    JudysDoor self
);

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

Generated hook

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

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

void SetupOpenDoorAnimationFeatures() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_SetupOpenDoorAnimationFeatures(
    JudysDoor self
);

float GetOpeningSpeed() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_GetOpeningSpeed(
    JudysDoor self
);

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

Generated hook

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

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

CName GetProperTransformAnimName() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_GetProperTransformAnimName(
    JudysDoor self
);

void SetNewDoorType(EDoorType type) RTTI

Generated hook

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

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

bool OnSetDoorType(SetDoorType evt) RTTI

Generated hook

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

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

bool OnSetCloseItself(SetCloseItself evt) RTTI

Generated hook

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

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

bool OnResetDoorState(ResetDoorState evt) RTTI

Generated hook

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

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

EDoorTriggerSide GetDoorTriggerSide(ent.Entity forEntity) RTTI

Generated hook

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

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

ent.Entity? GetPlayerEntity() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_GetPlayerEntity(
    JudysDoor self
);

void CreateLightSettings() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_CreateLightSettings(
    JudysDoor self
);

void SetSoloAppearance() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_SetSoloAppearance(
    JudysDoor self
);

void SetTechieAppearance() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_SetTechieAppearance(
    JudysDoor self
);

void SetNetrunnerAppearance() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_SetNetrunnerAppearance(
    JudysDoor self
);

void InitializeLight() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_InitializeLight(
    JudysDoor self
);

void GetAllActiveLights() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_GetAllActiveLights(
    JudysDoor self
);

EGameplayRole DeterminGameplayRole() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_DeterminGameplayRole(
    JudysDoor self
);

EMappinVisualState DeterminGameplayRoleMappinVisuaState(SDeviceMappinData data) overrideRTTI

Generated hook

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

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

bool IsActive() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_IsActive(
    JudysDoor self
);

void EnableOffMeshConnections(bool player, bool npc) overrideRTTI

Generated hook

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

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

void DisableOffMeshConnections(bool player, bool npc) overrideRTTI

Generated hook

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

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

bool CanPassAnySkillCheckOnParentTerminal() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_CanPassAnySkillCheckOnParentTerminal(
    JudysDoor self
);

float GetClosingAnimationLength() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_GetClosingAnimationLength(
    JudysDoor self
);

AnimFeatureDoor? GetAnimFeature() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_GetAnimFeature(
    JudysDoor self
);

bool IsNetrunner() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_IsNetrunner(
    JudysDoor self
);

bool HasAnyDirectInteractionActive() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct JudysDoor_HasAnyDirectInteractionActive(
    JudysDoor self
);