class

ArcadeMachine

11 properties
30 functions
1 derived class

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

Derived

Properties

Property	Type	Offset
`arcadeMachineType`	`ArcadeMachineType`	`0x3D0`	scripted
`isShortGlitchActive`	`bool`	`0x3D4`	scripted
`shortGlitchDelayID`	`game.DelayID`	`0x3D8`	scripted
`currentGameVideo`	`red.ResourceReferenceScriptToken`	`0x3E0`	scripted
`currentGameAudio`	`CName`	`0x3E8`	scripted
`currentGameAudioStop`	`CName`	`0x3F0`	scripted
`meshAppearanceOn`	`CName`	`0x3F8`	scripted
`meshAppearanceOff`	`CName`	`0x400`	scripted
`arcadeMinigameComponent`	`work.WorkspotResourceComponent?`	`0x408`	scripted
`minigame`	`ArcadeMinigame`	`0x418`	scripted
`combatStateListener`	`red.CallbackObject?`	`0x420`	scripted

Functions

bool OnRequestComponents(ent.EntityRequestComponentsInterface ri) overrideRTTI

Generated hook

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

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

bool OnPersitentStateInitialized(GameAttachedEvent evt) overrideRTTI

Generated hook

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

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

bool ResavePersistentData(game.PersistentState ps) overrideRTTI

Generated hook

re.Hooks.Place(
    "ArcadeMachine",
    "ResavePersistentData;PersistentState",
    (ArcadeMachine_ResavePersistentData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_ResavePersistentData(
    ArcadeMachine self,
    game.PersistentState? ps
);

bool OnTakeControl(ent.EntityResolveComponentsInterface ri) overrideRTTI

Generated hook

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

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

void ResolveGameplayState() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_ResolveGameplayState(
    ArcadeMachine self
);

void CreateBlackboard() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "ArcadeMachine",
    "CreateBlackboard;",
    (ArcadeMachine_CreateBlackboard x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_CreateBlackboard(
    ArcadeMachine self
);

ArcadeMachineBlackboardDef? GetBlackboardDef() overrideRTTI

Generated hook

re.Hooks.Place(
    "ArcadeMachine",
    "GetBlackboardDef;",
    (ArcadeMachine_GetBlackboardDef x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ArcadeMachineBlackboardDef>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_GetBlackboardDef(
    ArcadeMachine self
);

ArcadeMachineController? GetController() overrideRTTI

Generated hook

re.Hooks.Place(
    "ArcadeMachine",
    "GetController;",
    (ArcadeMachine_GetController x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ArcadeMachineController>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_GetController(
    ArcadeMachine self
);

ArcadeMachineControllerPS? GetDevicePS() overrideRTTI

Generated hook

re.Hooks.Place(
    "ArcadeMachine",
    "GetDevicePS;",
    (ArcadeMachine_GetDevicePS x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ArcadeMachineControllerPS>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_GetDevicePS(
    ArcadeMachine self
);

void StartGlitching(EGlitchState glitchState, float? intensity) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "ArcadeMachine",
    "StartGlitching;EGlitchStateFloat",
    (ArcadeMachine_StartGlitching x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_StartGlitching(
    ArcadeMachine self,
    EGlitchState glitchState,
    float? intensity
);

void StopGlitching() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "ArcadeMachine",
    "StopGlitching;",
    (ArcadeMachine_StopGlitching x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_StopGlitching(
    ArcadeMachine self
);

bool OnHitEvent(game.events.HitEvent hit) overrideRTTI

Generated hook

re.Hooks.Place(
    "ArcadeMachine",
    "OnHitEvent",
    (ArcadeMachine_OnHitEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_OnHitEvent(
    ArcadeMachine self,
    game.events.HitEvent? hit
);

void StartShortGlitch() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ArcadeMachine",
    "StartShortGlitch;",
    (ArcadeMachine_StartShortGlitch x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_StartShortGlitch(
    ArcadeMachine self
);

bool OnStopShortGlitch(StopShortGlitchEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "ArcadeMachine",
    "OnStopShortGlitch",
    (ArcadeMachine_OnStopShortGlitch x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_OnStopShortGlitch(
    ArcadeMachine self,
    StopShortGlitchEvent? evt
);

void TurnOnDevice() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_TurnOnDevice(
    ArcadeMachine self
);

void TurnOffDevice() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_TurnOffDevice(
    ArcadeMachine self
);

void CutPower() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "ArcadeMachine",
    "CutPower;",
    (ArcadeMachine_CutPower x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_CutPower(
    ArcadeMachine self
);

void TurnOffScreen() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ArcadeMachine",
    "TurnOffScreen;",
    (ArcadeMachine_TurnOffScreen x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_TurnOffScreen(
    ArcadeMachine self
);

void TurnOnScreen() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ArcadeMachine",
    "TurnOnScreen;",
    (ArcadeMachine_TurnOnScreen x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_TurnOnScreen(
    ArcadeMachine self
);

void OnDirectInteractionActive(game.interactions.InteractionActivationEvent evt, bool isInteractionActive) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "ArcadeMachine",
    "OnDirectInteractionActive;InteractionActivationEventBool",
    (ArcadeMachine_OnDirectInteractionActive x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_OnDirectInteractionActive(
    ArcadeMachine self,
    game.interactions.InteractionActivationEvent? evt,
    bool isInteractionActive
);

bool OnCombatStateChanged(int value) RTTI

Generated hook

re.Hooks.Place(
    "ArcadeMachine",
    "OnCombatStateChanged",
    (ArcadeMachine_OnCombatStateChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_OnCombatStateChanged(
    ArcadeMachine self,
    int value
);

bool OnBeginArcadeMinigameUI(BeginArcadeMinigameUI evt) RTTI

Generated hook

re.Hooks.Place(
    "ArcadeMachine",
    "OnBeginArcadeMinigameUI",
    (ArcadeMachine_OnBeginArcadeMinigameUI x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_OnBeginArcadeMinigameUI(
    ArcadeMachine self,
    BeginArcadeMinigameUI? evt
);

EGameplayRole DeterminGameplayRole() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_DeterminGameplayRole(
    ArcadeMachine self
);

void ApplyActiveStatusEffect(ent.EntityID target, TDBID statusEffect) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "ArcadeMachine",
    "ApplyActiveStatusEffect;EntityIDTweakDBID",
    (ArcadeMachine_ApplyActiveStatusEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_ApplyActiveStatusEffect(
    ArcadeMachine self,
    ent.EntityID target,
    TDBID statusEffect
);

void UploadActiveProgramOnNPC(ent.EntityID targetID) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "ArcadeMachine",
    "UploadActiveProgramOnNPC;EntityID",
    (ArcadeMachine_UploadActiveProgramOnNPC x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_UploadActiveProgramOnNPC(
    ArcadeMachine self,
    ent.EntityID targetID
);

void Setup() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ArcadeMachine",
    "Setup;",
    (ArcadeMachine_Setup x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_Setup(
    ArcadeMachine self
);

void SetupMinigame() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "ArcadeMachine",
    "SetupMinigame;",
    (ArcadeMachine_SetupMinigame x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_SetupMinigame(
    ArcadeMachine self
);

red.ResourceReferenceScriptToken GetArcadeGameVideo() RTTI

Generated hook

re.Hooks.Place(
    "ArcadeMachine",
    "GetArcadeGameVideo;",
    (ArcadeMachine_GetArcadeGameVideo x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.red.ResourceReferenceScriptToken>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_GetArcadeGameVideo(
    ArcadeMachine self
);

CName GetArcadeGameAudio() RTTI

Generated hook

re.Hooks.Place(
    "ArcadeMachine",
    "GetArcadeGameAudio;",
    (ArcadeMachine_GetArcadeGameAudio x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_GetArcadeGameAudio(
    ArcadeMachine self
);

CName GetArcadeGameAudioStop() RTTI

Generated hook

re.Hooks.Place(
    "ArcadeMachine",
    "GetArcadeGameAudioStop;",
    (ArcadeMachine_GetArcadeGameAudioStop x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct ArcadeMachine_GetArcadeGameAudioStop(
    ArcadeMachine self
);