class game.ui

HackingMinigameGameController

game.ui.HackingMinigameGameController

20 properties
31 functions

Extends game.ui.WidgetGameController world.ui.IWidgetGameController ink.IWidgetController IScriptable ISerializable

Properties

Property	Type	Offset
`symbolsRecordTDBID`	`TDBID`	`0x1E0`
`minigameDefaultsTDBID`	`TDBID`	`0x1E8`
`deviceMode`	`bool`	`0x1FE`
`isAlternativeVariant`	`bool`	`0x0`	scripted
`helpInputHintRef`	`ink.WidgetReference`	`0x8`	scripted
`miniGameRecord`	`WeakHandle<game.data.Minigame_Def_Record>`	`0x20`	scripted
`dimension`	`int`	`0x30`	scripted
`isTutorialActive`	`bool`	`0x34`	scripted
`isOfficerBreach`	`bool`	`0x35`	scripted
`isRemoteBreach`	`bool`	`0x36`	scripted
`isItemBreach`	`bool`	`0x37`	scripted
`numberAttempts`	`int`	`0x38`	scripted
`tooltipsManagerRef`	`ink.WidgetReference`	`0x40`	scripted
`TooltipsManager`	`WeakHandle<game.ui.TooltipsManager>`	`0x58`	scripted
`uiSystem`	`game.ui.GameSystemUI?`	`0x68`	scripted
`contextHelpOverlay`	`bool`	`0x78`	scripted
`bbMinigame`	`WeakHandle<game.IBlackboard>`	`0x80`	scripted
`bbMinigameStateListener`	`red.CallbackObject?`	`0x90`	scripted
`bbUiData`	`WeakHandle<game.IBlackboard>`	`0xA0`	scripted
`bbControllerStateListener`	`red.CallbackObject?`	`0xB0`	scripted

Functions

game.ui.CharactersChain[] GetProgramsChains() RTTI
game.ui.UnlockableProgram[] GetUnlockablePrograms() RTTI

int GetRarity(float rarityValue) RTTI

Generated hook

re.Hooks.Place(
    "gameuiHackingMinigameGameController",
    "GetRarity",
    (HackingMinigameGameController_GetRarity x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_GetRarity(
    game.ui.HackingMinigameGameController self,
    float rarityValue
);

game.data.MiniGame_Trap_Record? GetTrapByProbability(float probabilityValue) RTTI

Generated hook

re.Hooks.Place(
    "gameuiHackingMinigameGameController",
    "GetTrapByProbability",
    (HackingMinigameGameController_GetTrapByProbability x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.MiniGame_Trap_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_GetTrapByProbability(
    game.ui.HackingMinigameGameController self,
    float probabilityValue
);

game.ui.MinigameProgramData[] GetPlayerPrograms() RTTI

void SetTrapIconAtCell(Vector2 cellCoordinates, CName trap) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiHackingMinigameGameController",
    "SetTrapIconAtCell",
    (HackingMinigameGameController_SetTrapIconAtCell x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_SetTrapIconAtCell(
    game.ui.HackingMinigameGameController self,
    Vector2 cellCoordinates,
    CName trap
);

void AddUnlockableProgram(game.ui.UnlockableProgram program, uint[] instruction) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiHackingMinigameGameController",
    "AddUnlockableProgram",
    (HackingMinigameGameController_AddUnlockableProgram x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_AddUnlockableProgram(
    game.ui.HackingMinigameGameController self,
    game.ui.UnlockableProgram program,
    uint[] instruction
);

void PauseTheTimer() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiHackingMinigameGameController",
    "PauseTheTimer",
    (HackingMinigameGameController_PauseTheTimer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_PauseTheTimer(
    game.ui.HackingMinigameGameController self
);

void ResumeTheTimer() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiHackingMinigameGameController",
    "ResumeTheTimer",
    (HackingMinigameGameController_ResumeTheTimer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_ResumeTheTimer(
    game.ui.HackingMinigameGameController self
);

void EnableWhitelist(bool enable) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiHackingMinigameGameController",
    "EnableWhitelist",
    (HackingMinigameGameController_EnableWhitelist x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_EnableWhitelist(
    game.ui.HackingMinigameGameController self,
    bool enable
);

bool IsWhitelistEnabled() RTTI

Generated hook

re.Hooks.Place(
    "gameuiHackingMinigameGameController",
    "IsWhitelistEnabled",
    (HackingMinigameGameController_IsWhitelistEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_IsWhitelistEnabled(
    game.ui.HackingMinigameGameController self
);

void WhitelistPosition(Vector2 position) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiHackingMinigameGameController",
    "WhitelistPosition",
    (HackingMinigameGameController_WhitelistPosition x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_WhitelistPosition(
    game.ui.HackingMinigameGameController self,
    Vector2 position
);

void RemoveWhitelistedPosition(Vector2 position) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiHackingMinigameGameController",
    "RemoveWhitelistedPosition",
    (HackingMinigameGameController_RemoveWhitelistedPosition x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_RemoveWhitelistedPosition(
    game.ui.HackingMinigameGameController self,
    Vector2 position
);

bool OnInitialize() RTTI

Generated hook

re.Hooks.Place(
    "gameuiHackingMinigameGameController",
    "OnInitialize",
    (HackingMinigameGameController_OnInitialize x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_OnInitialize(
    game.ui.HackingMinigameGameController self
);

bool OnUninitialize() RTTI

Generated hook

re.Hooks.Place(
    "gameuiHackingMinigameGameController",
    "OnUninitialize",
    (HackingMinigameGameController_OnUninitialize x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_OnUninitialize(
    game.ui.HackingMinigameGameController self
);

bool OnGameStateChanged(int value) RTTI

Generated hook

re.Hooks.Place(
    "gameuiHackingMinigameGameController",
    "OnGameStateChanged",
    (HackingMinigameGameController_OnGameStateChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_OnGameStateChanged(
    game.ui.HackingMinigameGameController self,
    int value
);

bool OnHandleInput(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameuiHackingMinigameGameController",
    "OnHandleInput",
    (HackingMinigameGameController_OnHandleInput x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_OnHandleInput(
    game.ui.HackingMinigameGameController self,
    ink.PointerEvent? evt
);

bool OnDisconnectController(bool isDisconnected) RTTI

Generated hook

re.Hooks.Place(
    "gameuiHackingMinigameGameController",
    "OnDisconnectController",
    (HackingMinigameGameController_OnDisconnectController x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_OnDisconnectController(
    game.ui.HackingMinigameGameController self,
    bool isDisconnected
);

bool OnPositionSelected(Vector2 position) RTTI

Generated hook

re.Hooks.Place(
    "gameuiHackingMinigameGameController",
    "OnPositionSelected",
    (HackingMinigameGameController_OnPositionSelected x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_OnPositionSelected(
    game.ui.HackingMinigameGameController self,
    Vector2 position
);

void ToggleTutorialOverlay(bool value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiHackingMinigameGameController",
    "ToggleTutorialOverlay;Bool",
    (HackingMinigameGameController_ToggleTutorialOverlay x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_ToggleTutorialOverlay(
    game.ui.HackingMinigameGameController self,
    bool value
);

void PrepareTooltips() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiHackingMinigameGameController",
    "PrepareTooltips;",
    (HackingMinigameGameController_PrepareTooltips x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_PrepareTooltips(
    game.ui.HackingMinigameGameController self
);

bool OnShowTooltipRequest(MinigameTooltipShowRequest request) RTTI

Generated hook

re.Hooks.Place(
    "gameuiHackingMinigameGameController",
    "OnShowTooltipRequest",
    (HackingMinigameGameController_OnShowTooltipRequest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_OnShowTooltipRequest(
    game.ui.HackingMinigameGameController self,
    MinigameTooltipShowRequest? request
);

bool OnHideTooltipRequest(MinigameTooltipHideRequest request) RTTI

Generated hook

re.Hooks.Place(
    "gameuiHackingMinigameGameController",
    "OnHideTooltipRequest",
    (HackingMinigameGameController_OnHideTooltipRequest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_OnHideTooltipRequest(
    game.ui.HackingMinigameGameController self,
    MinigameTooltipHideRequest? request
);

bool OnGridCellPressed(bool wasHorizontalyActive) RTTI

Generated hook

re.Hooks.Place(
    "gameuiHackingMinigameGameController",
    "OnGridCellPressed",
    (HackingMinigameGameController_OnGridCellPressed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_OnGridCellPressed(
    game.ui.HackingMinigameGameController self,
    bool wasHorizontalyActive
);

void ProcessMinigameGridClickTutorialFacts(bool horizontal) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiHackingMinigameGameController",
    "ProcessMinigameGridClickTutorialFacts;Bool",
    (HackingMinigameGameController_ProcessMinigameGridClickTutorialFacts x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_ProcessMinigameGridClickTutorialFacts(
    game.ui.HackingMinigameGameController self,
    bool horizontal
);

bool ProcessMinigameTutorialFact(PlayerPuppet player) RTTI

Generated hook

re.Hooks.Place(
    "gameuiHackingMinigameGameController",
    "ProcessMinigameTutorialFact;PlayerPuppet",
    (HackingMinigameGameController_ProcessMinigameTutorialFact x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_ProcessMinigameTutorialFact(
    game.ui.HackingMinigameGameController self,
    PlayerPuppet? player
);

void ScaleBoard(ent.Entity entity, out int size, float powerLevel, out game.data.MiniGame_AllSymbols_Record symbolsToUse)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiHackingMinigameGameController",
    "ScaleBoard;EntityInt32FloatMiniGame_AllSymbols_Record",
    (HackingMinigameGameController_ScaleBoard x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_ScaleBoard(
    game.ui.HackingMinigameGameController self,
    ent.Entity? entity,
    int size,
    float powerLevel,
    game.data.MiniGame_AllSymbols_Record? symbolsToUse
);

void ScaleTraps(ent.Entity entity, PlayerPuppet player, out float prob, float powerLevel) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiHackingMinigameGameController",
    "ScaleTraps;EntityPlayerPuppetFloatFloat",
    (HackingMinigameGameController_ScaleTraps x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_ScaleTraps(
    game.ui.HackingMinigameGameController self,
    ent.Entity? entity,
    PlayerPuppet? player,
    float prob,
    float powerLevel
);

void ScaleTimer(PlayerPuppet player, ent.Entity entity, out float time, float powerLevel, out bool waitInteraction) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiHackingMinigameGameController",
    "ScaleTimer;PlayerPuppetEntityFloatFloatBool",
    (HackingMinigameGameController_ScaleTimer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_ScaleTimer(
    game.ui.HackingMinigameGameController self,
    PlayerPuppet? player,
    ent.Entity? entity,
    float time,
    float powerLevel,
    bool waitInteraction
);

void FilterTraps(game.data.MiniGame_Trap_Record[] trapList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiHackingMinigameGameController",
    "FilterTraps;script_ref<array<MiniGame_Trap_Record>>",
    (HackingMinigameGameController_FilterTraps x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_FilterTraps(
    game.ui.HackingMinigameGameController self,
    game.data.MiniGame_Trap_Record[] trapList
);

void ScaleBuffer(ent.Entity entity, out float size, float powerLevel, PlayerPuppet player) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiHackingMinigameGameController",
    "ScaleBuffer;EntityFloatFloatPlayerPuppet",
    (HackingMinigameGameController_ScaleBuffer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMinigameGameController_ScaleBuffer(
    game.ui.HackingMinigameGameController self,
    ent.Entity? entity,
    float size,
    float powerLevel,
    PlayerPuppet? player
);