class

ExplosiveDevice

20 properties
51 functions
3 derived classes

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

Derived

C4, ExplosiveTriggerDevice, SensorDevice

Properties

Property	Type	Offset
`numberOfComponentsToON`	`int`	`0x440`	scripted
`numberOfComponentsToOFF`	`int`	`0x444`	scripted
`indexesOfComponentsToOFF`	`int[]`	`0x448`	scripted
`shouldDistractionEnableCollider`	`bool`	`0x458`	scripted
`shouldDistractionVFXstay`	`bool`	`0x459`	scripted
`loopAudioEvent`	`CName`	`0x460`	scripted
`spawnedFxInstancesToKill`	`game.FxInstance?[]`	`0x468`	scripted
`mesh`	`ent.MeshComponent?`	`0x478`	scripted
`collider`	`ent.IPlacedComponent?`	`0x488`	scripted
`distractionCollider`	`ent.IPlacedComponent?`	`0x498`	scripted
`numberOfReceivedHits`	`int`	`0x4A8`	scripted
`devicePenetrationHealth`	`float`	`0x4AC`	scripted
`killedByExplosion`	`bool`	`0x4B0`	scripted
`distractionTimeStart`	`float`	`0x4B4`	scripted
`isBroadcastingEnvironmentalHazardStim`	`bool`	`0x4B8`	scripted
`explodedByQuickhack`	`bool`	`0x4B9`	scripted
`switchAppearanceOnExplosion`	`bool`	`0x4BA`	scripted
`explodedAppearanceName`	`CName`	`0x4C0`	scripted
`componentsON`	`ent.IPlacedComponent?[]`	`0x4C8`	scripted
`componentsOFF`	`ent.IPlacedComponent?[]`	`0x4D8`	scripted

Functions

bool OnPostInitialize(ent.PostInitializeEvent evt) overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_OnPostInitialize(
    ExplosiveDevice self,
    ent.PostInitializeEvent? evt
);

bool OnPreUninitialize(ent.PreUninitializeEvent evt) overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_OnPreUninitialize(
    ExplosiveDevice self,
    ent.PreUninitializeEvent? evt
);

bool OnRequestComponents(ent.EntityRequestComponentsInterface ri) overrideRTTI

Generated hook

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

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

bool OnTakeControl(ent.EntityResolveComponentsInterface ri) overrideRTTI

Generated hook

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

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

void ResolveGameplayState() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_ResolveGameplayState(
    ExplosiveDevice self
);

ExplosiveDeviceController? GetController() overrideRTTI

Generated hook

re.Hooks.Place(
    "ExplosiveDevice",
    "GetController;",
    (ExplosiveDevice_GetController x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ExplosiveDeviceController>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_GetController(
    ExplosiveDevice self
);

ExplosiveDeviceControllerPS? GetDevicePS() overrideRTTI

Generated hook

re.Hooks.Place(
    "ExplosiveDevice",
    "GetDevicePS;",
    (ExplosiveDevice_GetDevicePS x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ExplosiveDeviceControllerPS>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_GetDevicePS(
    ExplosiveDevice self
);

bool OnDeath(game.events.DeathEvent evt) overrideRTTI

Generated hook

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

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

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

Generated hook

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

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

float GetAttackRange(TDBID attackTDBID) RTTI

Generated hook

re.Hooks.Place(
    "ExplosiveDevice",
    "GetAttackRange;TweakDBID",
    (ExplosiveDevice_GetAttackRange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_GetAttackRange(
    ExplosiveDevice self,
    TDBID attackTDBID
);

void StartExplosionPipeline(WeakHandle<game.Object> instigator, float? additionalDelays) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ExplosiveDevice",
    "StartExplosionPipeline;GameObjectFloat",
    (ExplosiveDevice_StartExplosionPipeline x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_StartExplosionPipeline(
    ExplosiveDevice self,
    WeakHandle<game.Object> instigator,
    float? additionalDelays
);

bool OnExplosiveDeviceDelayedEvent(ExplosiveDeviceDelayedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ExplosiveDevice",
    "OnExplosiveDeviceDelayedEvent",
    (ExplosiveDevice_OnExplosiveDeviceDelayedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_OnExplosiveDeviceDelayedEvent(
    ExplosiveDevice self,
    ExplosiveDeviceDelayedEvent? evt
);

void Explode(int index, WeakHandle<game.Object> instigator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ExplosiveDevice",
    "Explode;Int32GameObject",
    (ExplosiveDevice_Explode x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void DoPhysicsPulse(TDBID damageType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ExplosiveDevice",
    "DoPhysicsPulse;TweakDBID",
    (ExplosiveDevice_DoPhysicsPulse x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_DoPhysicsPulse(
    ExplosiveDevice self,
    TDBID damageType
);

void Explosion(int index) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ExplosiveDevice",
    "Explosion;Int32",
    (ExplosiveDevice_Explosion x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_Explosion(
    ExplosiveDevice self,
    int index
);

bool OnExplosiveDeviceHideDeviceEvent(ExplosiveDeviceHideDeviceEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ExplosiveDevice",
    "OnExplosiveDeviceHideDeviceEvent",
    (ExplosiveDevice_OnExplosiveDeviceHideDeviceEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_OnExplosiveDeviceHideDeviceEvent(
    ExplosiveDevice self,
    ExplosiveDeviceHideDeviceEvent? evt
);

void DoAttack(TDBID damageType, WeakHandle<game.Object>? instigator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ExplosiveDevice",
    "DoAttack;TweakDBIDGameObject",
    (ExplosiveDevice_DoAttack x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_DoAttack(
    ExplosiveDevice self,
    TDBID damageType,
    WeakHandle<game.Object>? instigator
);

void DoAdditionalGameEffect(EExplosiveAdditionalGameEffectType additionalGameEffect) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ExplosiveDevice",
    "DoAdditionalGameEffect;EExplosiveAdditionalGameEffectType",
    (ExplosiveDevice_DoAdditionalGameEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_DoAdditionalGameEffect(
    ExplosiveDevice self,
    EExplosiveAdditionalGameEffectType additionalGameEffect
);

void ToggleVisibility(bool visible) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ExplosiveDevice",
    "ToggleVisibility;Bool",
    (ExplosiveDevice_ToggleVisibility x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_ToggleVisibility(
    ExplosiveDevice self,
    bool visible
);

void SendSwapMeshDelayedEvent(float delay) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ExplosiveDevice",
    "SendSwapMeshDelayedEvent;Float",
    (ExplosiveDevice_SendSwapMeshDelayedEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool OnSwapMeshDelayedEvent(SwapMeshDelayedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ExplosiveDevice",
    "OnSwapMeshDelayedEvent",
    (ExplosiveDevice_OnSwapMeshDelayedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_OnSwapMeshDelayedEvent(
    ExplosiveDevice self,
    SwapMeshDelayedEvent? evt
);

void KillAllFxInstances() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ExplosiveDevice",
    "KillAllFxInstances;",
    (ExplosiveDevice_KillAllFxInstances x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_KillAllFxInstances(
    ExplosiveDevice self
);

bool SpawnVFXs(CName[] fxEventName) RTTI

Generated hook

re.Hooks.Place(
    "ExplosiveDevice",
    "SpawnVFXs;script_ref<array<CName>>",
    (ExplosiveDevice_SpawnVFXs x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_SpawnVFXs(
    ExplosiveDevice self,
    CName[] fxEventName
);

void SpawnVFXs(game.FxResource fx, Vector4? newPosition, Vector4? hitDirection) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ExplosiveDevice",
    "SpawnVFXs;FxResourceVector4Vector4",
    (ExplosiveDevice_SpawnVFXs2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_SpawnVFXs2(
    ExplosiveDevice self,
    game.FxResource fx,
    Vector4? newPosition,
    Vector4? hitDirection
);

bool OnSpiderbotExplodeExplosiveDevicePerformed(SpiderbotExplodeExplosiveDevicePerformed evt) RTTI

Generated hook

re.Hooks.Place(
    "ExplosiveDevice",
    "OnSpiderbotExplodeExplosiveDevicePerformed",
    (ExplosiveDevice_OnSpiderbotExplodeExplosiveDevicePerformed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_OnSpiderbotExplodeExplosiveDevicePerformed(
    ExplosiveDevice self,
    SpiderbotExplodeExplosiveDevicePerformed? evt
);

bool OnSpiderbotDistractExplosiveDevicePerformed(SpiderbotDistractExplosiveDevicePerformed evt) RTTI

Generated hook

re.Hooks.Place(
    "ExplosiveDevice",
    "OnSpiderbotDistractExplosiveDevicePerformed",
    (ExplosiveDevice_OnSpiderbotDistractExplosiveDevicePerformed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_OnSpiderbotDistractExplosiveDevicePerformed(
    ExplosiveDevice self,
    SpiderbotDistractExplosiveDevicePerformed? evt
);

bool OnQuestForceDetonate(QuestForceDetonate evt) RTTI

Generated hook

re.Hooks.Place(
    "ExplosiveDevice",
    "OnQuestForceDetonate",
    (ExplosiveDevice_OnQuestForceDetonate x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_OnQuestForceDetonate(
    ExplosiveDevice self,
    QuestForceDetonate? evt
);

bool OnForceDetonate(ForceDetonate evt) RTTI

Generated hook

re.Hooks.Place(
    "ExplosiveDevice",
    "OnForceDetonate",
    (ExplosiveDevice_OnForceDetonate x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_OnForceDetonate(
    ExplosiveDevice self,
    ForceDetonate? evt
);

bool OnQuickHackExplodeExplosive(QuickHackExplodeExplosive evt) RTTI

Generated hook

re.Hooks.Place(
    "ExplosiveDevice",
    "OnQuickHackExplodeExplosive",
    (ExplosiveDevice_OnQuickHackExplodeExplosive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_OnQuickHackExplodeExplosive(
    ExplosiveDevice self,
    QuickHackExplodeExplosive? evt
);

bool OnQuickHackDistractExplosive(QuickHackDistractExplosive evt) RTTI

Generated hook

re.Hooks.Place(
    "ExplosiveDevice",
    "OnQuickHackDistractExplosive",
    (ExplosiveDevice_OnQuickHackDistractExplosive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_OnQuickHackDistractExplosive(
    ExplosiveDevice self,
    QuickHackDistractExplosive? evt
);

void TurnOffDevice() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "ExplosiveDevice",
    "TurnOffDevice;",
    (ExplosiveDevice_TurnOffDevice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_TurnOffDevice(
    ExplosiveDevice self
);

void TurnOnDevice() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "ExplosiveDevice",
    "TurnOnDevice;",
    (ExplosiveDevice_TurnOnDevice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_TurnOnDevice(
    ExplosiveDevice self
);

void ToggleComponentsON_OFF(bool visible) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ExplosiveDevice",
    "ToggleComponentsON_OFF;Bool",
    (ExplosiveDevice_ToggleComponentsON_OFF x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_ToggleComponentsON_OFF(
    ExplosiveDevice self,
    bool visible
);

void ToggleLightsON_OFF(bool on) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ExplosiveDevice",
    "ToggleLightsON_OFF;Bool",
    (ExplosiveDevice_ToggleLightsON_OFF x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void StartDistraction(bool? loopAnimation) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "ExplosiveDevice",
    "StartDistraction;Bool",
    (ExplosiveDevice_StartDistraction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_StartDistraction(
    ExplosiveDevice self,
    bool? loopAnimation
);

void StopDistraction() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "ExplosiveDevice",
    "StopDistraction;",
    (ExplosiveDevice_StopDistraction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_StopDistraction(
    ExplosiveDevice self
);

EGameplayRole DeterminGameplayRole() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_DeterminGameplayRole(
    ExplosiveDevice self
);

float DeterminGameplayRoleMappinRange(SDeviceMappinData data) overrideRTTI

Generated hook

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

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

bool OnHit(game.events.HitEvent evt) overrideRTTI

Generated hook

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

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

void DamagePipelineFinalized(game.events.HitEvent evt) overrideRTTI

Generated hook

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

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

bool OnDamageReceived(game.events.DamageReceivedEvent evt) overrideRTTI

Generated hook

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

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

void InitializeHealthDecay(float health, float delay) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ExplosiveDevice",
    "InitializeHealthDecay;FloatFloat",
    (ExplosiveDevice_InitializeHealthDecay x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_InitializeHealthDecay(
    ExplosiveDevice self,
    float health,
    float delay
);

void BroadcastEnvironmentalHazardStimuli() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ExplosiveDevice",
    "BroadcastEnvironmentalHazardStimuli;",
    (ExplosiveDevice_BroadcastEnvironmentalHazardStimuli x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_BroadcastEnvironmentalHazardStimuli(
    ExplosiveDevice self
);

void RemoveEnvironmentalHazardStimuli() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ExplosiveDevice",
    "RemoveEnvironmentalHazardStimuli;",
    (ExplosiveDevice_RemoveEnvironmentalHazardStimuli x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_RemoveEnvironmentalHazardStimuli(
    ExplosiveDevice self
);

bool ValidateRelicCWAttack(game.damage.AttackData attackData) RTTI

Generated hook

re.Hooks.Place(
    "ExplosiveDevice",
    "ValidateRelicCWAttack;AttackData",
    (ExplosiveDevice_ValidateRelicCWAttack x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_ValidateRelicCWAttack(
    ExplosiveDevice self,
    game.damage.AttackData? attackData
);

bool IsExplosive() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_IsExplosive(
    ExplosiveDevice self
);

bool CanOverrideNetworkContext() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_CanOverrideNetworkContext(
    ExplosiveDevice self
);

bool HasImportantInteraction() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_HasImportantInteraction(
    ExplosiveDevice self
);

bool HasAnyDirectInteractionActive() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_HasAnyDirectInteractionActive(
    ExplosiveDevice self
);

EFocusOutlineType GetCurrentOutline() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_GetCurrentOutline(
    ExplosiveDevice self
);

FocusForcedHighlightData? GetDefaultHighlight() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ExplosiveDevice_GetDefaultHighlight(
    ExplosiveDevice self
);