class game.ui

GameSystemUI

game.ui.GameSystemUI

0 properties
44 functions

Extends game.ui.IGameSystemUI game.IGameSystem IScriptable ISerializable

Properties

None.

Functions

ScriptGameInstance GetGameInstance() RTTI

Generated hook

re.Hooks.Place(
    "gameuiGameSystemUI",
    "GetGameInstance",
    (GameSystemUI_GetGameInstance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ScriptGameInstance>();
    }
);

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

void QueueEvent(red.Event evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "QueueEvent",
    (GameSystemUI_QueueEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_QueueEvent(
    game.ui.GameSystemUI self,
    red.Event? evt
);

void QueueMenuEvent(CName eventName, IScriptable? userData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "QueueMenuEvent",
    (GameSystemUI_QueueMenuEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_QueueMenuEvent(
    game.ui.GameSystemUI self,
    CName eventName,
    IScriptable? userData
);

void RequestVendorMenu(quest.VendorPanelData data, CName? scenarioName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "RequestVendorMenu",
    (GameSystemUI_RequestVendorMenu x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_RequestVendorMenu(
    game.ui.GameSystemUI self,
    quest.VendorPanelData? data,
    CName? scenarioName
);

void RequestFastTravelMenu() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "RequestFastTravelMenu",
    (GameSystemUI_RequestFastTravelMenu x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void RequestDelamainTaxiMenu() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "RequestDelamainTaxiMenu",
    (GameSystemUI_RequestDelamainTaxiMenu x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void ShowTutorialBracket(game.TutorialBracketData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "ShowTutorialBracket",
    (GameSystemUI_ShowTutorialBracket x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_ShowTutorialBracket(
    game.ui.GameSystemUI self,
    game.TutorialBracketData data
);

void HideTutorialBracket(CName bracketID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "HideTutorialBracket",
    (GameSystemUI_HideTutorialBracket x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_HideTutorialBracket(
    game.ui.GameSystemUI self,
    CName bracketID
);

void ShowTutorialOverlay(game.TutorialOverlayData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "ShowTutorialOverlay",
    (GameSystemUI_ShowTutorialOverlay x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_ShowTutorialOverlay(
    game.ui.GameSystemUI self,
    game.TutorialOverlayData data
);

void HideTutorialOverlay(game.TutorialOverlayData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "HideTutorialOverlay",
    (GameSystemUI_HideTutorialOverlay x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_HideTutorialOverlay(
    game.ui.GameSystemUI self,
    game.TutorialOverlayData data
);

void SetGlobalThemeOverride(CName themeID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "SetGlobalThemeOverride",
    (GameSystemUI_SetGlobalThemeOverride x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_SetGlobalThemeOverride(
    game.ui.GameSystemUI self,
    CName themeID
);

void ClearGlobalThemeOverride() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "ClearGlobalThemeOverride",
    (GameSystemUI_ClearGlobalThemeOverride x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

game.ui.PatchIntroPackage GetNeededPatchIntroPackage() RTTI

Generated hook

re.Hooks.Place(
    "gameuiGameSystemUI",
    "GetNeededPatchIntroPackage",
    (GameSystemUI_GetNeededPatchIntroPackage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ui.PatchIntroPackage>();
    }
);

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

bool IsPatchIntroNeeded(game.ui.PatchIntro patchIntro) RTTI

Generated hook

re.Hooks.Place(
    "gameuiGameSystemUI",
    "IsPatchIntroNeeded",
    (GameSystemUI_IsPatchIntroNeeded x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_IsPatchIntroNeeded(
    game.ui.GameSystemUI self,
    game.ui.PatchIntro patchIntro
);

void MarkPatchIntroAsSeen(game.ui.PatchIntro patchIntro) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "MarkPatchIntroAsSeen",
    (GameSystemUI_MarkPatchIntroAsSeen x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_MarkPatchIntroAsSeen(
    game.ui.GameSystemUI self,
    game.ui.PatchIntro patchIntro
);

void ResetPatchIntro(game.ui.PatchIntro patchIntro) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "ResetPatchIntro",
    (GameSystemUI_ResetPatchIntro x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_ResetPatchIntro(
    game.ui.GameSystemUI self,
    game.ui.PatchIntro patchIntro
);

Vector2 GetCurrentWindowSize() RTTI

Generated hook

re.Hooks.Place(
    "gameuiGameSystemUI",
    "GetCurrentWindowSize",
    (GameSystemUI_GetCurrentWindowSize x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector2>();
    }
);

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

float GetInverseUIScale() RTTI

Generated hook

re.Hooks.Place(
    "gameuiGameSystemUI",
    "GetInverseUIScale",
    (GameSystemUI_GetInverseUIScale x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

Vector2 GetBlackBarsSizes() RTTI

Generated hook

re.Hooks.Place(
    "gameuiGameSystemUI",
    "GetBlackBarsSizes",
    (GameSystemUI_GetBlackBarsSizes x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector2>();
    }
);

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

float GetHudScalingOverride() RTTI

Generated hook

re.Hooks.Place(
    "gameuiGameSystemUI",
    "GetHudScalingOverride",
    (GameSystemUI_GetHudScalingOverride x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

void NotifyFastTravelStart() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "NotifyFastTravelStart",
    (GameSystemUI_NotifyFastTravelStart x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void SetOneTimeMessageSeen(game.ui.OneTimeMessage message, bool seen) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "SetOneTimeMessageSeen",
    (GameSystemUI_SetOneTimeMessageSeen x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_SetOneTimeMessageSeen(
    game.ui.GameSystemUI self,
    game.ui.OneTimeMessage message,
    bool seen
);

bool GetOneTimeMessageSeen(game.ui.OneTimeMessage message) RTTI

Generated hook

re.Hooks.Place(
    "gameuiGameSystemUI",
    "GetOneTimeMessageSeen",
    (GameSystemUI_GetOneTimeMessageSeen x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_GetOneTimeMessageSeen(
    game.ui.GameSystemUI self,
    game.ui.OneTimeMessage message
);

void SetHudEntryForcedVisibility(CName entryName, world.ui.EntryVisibility visibility) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "SetHudEntryForcedVisibility",
    (GameSystemUI_SetHudEntryForcedVisibility x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_SetHudEntryForcedVisibility(
    game.ui.GameSystemUI self,
    CName entryName,
    world.ui.EntryVisibility visibility
);

world.ui.EntryVisibility GetHudEntryForcedVisibility(CName entryName) RTTI

Generated hook

re.Hooks.Place(
    "gameuiGameSystemUI",
    "GetHudEntryForcedVisibility",
    (GameSystemUI_GetHudEntryForcedVisibility x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.world.ui.EntryVisibility>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_GetHudEntryForcedVisibility(
    game.ui.GameSystemUI self,
    CName entryName
);

void SetNavigationOppositeAxisDistanceCost(float cost) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "SetNavigationOppositeAxisDistanceCost",
    (GameSystemUI_SetNavigationOppositeAxisDistanceCost x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_SetNavigationOppositeAxisDistanceCost(
    game.ui.GameSystemUI self,
    float cost
);

void ResetNavigationOppositeAxisDistanceCost() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "ResetNavigationOppositeAxisDistanceCost",
    (GameSystemUI_ResetNavigationOppositeAxisDistanceCost x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

WeakHandle<ink.Widget> GetInteractableWidgetUnderCursor() RTTI

void SetIsEulaAccepted(bool isEulaAccepted) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "SetIsEulaAccepted",
    (GameSystemUI_SetIsEulaAccepted x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_SetIsEulaAccepted(
    game.ui.GameSystemUI self,
    bool isEulaAccepted
);

bool GetIsEulaAccepted() RTTI

Generated hook

re.Hooks.Place(
    "gameuiGameSystemUI",
    "GetIsEulaAccepted",
    (GameSystemUI_GetIsEulaAccepted x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void PushGameContext(UIGameContext context) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "PushGameContext;UIGameContext",
    (GameSystemUI_PushGameContext x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_PushGameContext(
    game.ui.GameSystemUI self,
    UIGameContext context
);

void PopGameContext(UIGameContext context, bool? invalidate) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "PopGameContext;UIGameContextBool",
    (GameSystemUI_PopGameContext x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_PopGameContext(
    game.ui.GameSystemUI self,
    UIGameContext context,
    bool? invalidate
);

void SwapGameContext(UIGameContext oldContext, UIGameContext newContext) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "SwapGameContext;UIGameContextUIGameContext",
    (GameSystemUI_SwapGameContext x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_SwapGameContext(
    game.ui.GameSystemUI self,
    UIGameContext oldContext,
    UIGameContext newContext
);

void ResetGameContext() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "ResetGameContext;",
    (GameSystemUI_ResetGameContext x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void RequestNewVisualState(CName newVisualState) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "RequestNewVisualState;CName",
    (GameSystemUI_RequestNewVisualState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_RequestNewVisualState(
    game.ui.GameSystemUI self,
    CName newVisualState
);

void RestorePreviousVisualState(CName popVisualState) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "RestorePreviousVisualState;CName",
    (GameSystemUI_RestorePreviousVisualState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_RestorePreviousVisualState(
    game.ui.GameSystemUI self,
    CName popVisualState
);

FastTravelSystem? GetFastTravelSystem() RTTI

Generated hook

re.Hooks.Place(
    "gameuiGameSystemUI",
    "GetFastTravelSystem;",
    (GameSystemUI_GetFastTravelSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.FastTravelSystem>();
    }
);

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

void NotifyFastTravelSystem(bool menuEnabled) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "NotifyFastTravelSystem;Bool",
    (GameSystemUI_NotifyFastTravelSystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_NotifyFastTravelSystem(
    game.ui.GameSystemUI self,
    bool menuEnabled
);

bool OnEnterFastTravelMenu() RTTI

Generated hook

re.Hooks.Place(
    "gameuiGameSystemUI",
    "OnEnterFastTravelMenu",
    (GameSystemUI_OnEnterFastTravelMenu x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool OnExitFastTravelMenu() RTTI

Generated hook

re.Hooks.Place(
    "gameuiGameSystemUI",
    "OnExitFastTravelMenu",
    (GameSystemUI_OnExitFastTravelMenu x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

DelamainTaxiSystem? GetDelamainTaxiSystem() RTTI

Generated hook

re.Hooks.Place(
    "gameuiGameSystemUI",
    "GetDelamainTaxiSystem;",
    (GameSystemUI_GetDelamainTaxiSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.DelamainTaxiSystem>();
    }
);

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

void NotifyDelamainTaxiSystem(bool menuEnabled) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiGameSystemUI",
    "NotifyDelamainTaxiSystem;Bool",
    (GameSystemUI_NotifyDelamainTaxiSystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameSystemUI_NotifyDelamainTaxiSystem(
    game.ui.GameSystemUI self,
    bool menuEnabled
);

bool OnEnterDelamainTaxiMenu() RTTI

Generated hook

re.Hooks.Place(
    "gameuiGameSystemUI",
    "OnEnterDelamainTaxiMenu",
    (GameSystemUI_OnEnterDelamainTaxiMenu x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool OnExitDelamainTaxiMenu() RTTI

Generated hook

re.Hooks.Place(
    "gameuiGameSystemUI",
    "OnExitDelamainTaxiMenu",
    (GameSystemUI_OnExitDelamainTaxiMenu x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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