class

SingleplayerMenuGameController

53 properties
73 functions

Extends game.ui.MainMenuGameController game.ui.MenuItemListGameController game.ui.SaveHandlingController game.ui.MenuGameController game.ui.WidgetGameController world.ui.IWidgetGameController ink.IWidgetController IScriptable ISerializable

Properties

Property	Type	Offset
`baseLogoContainer`	`ink.CompoundWidgetReference`	`0x48`	scripted
`ep1LogoContainer`	`ink.CompoundWidgetReference`	`0x60`	scripted
`gogButtonWidgetRef`	`ink.WidgetReference`	`0x78`	scripted
`accountSelector`	`ink.CompoundWidgetReference`	`0x90`	scripted
`gameVersionButton`	`ink.CompoundWidgetReference`	`0xA8`	scripted
`patch2Notification`	`ink.CompoundWidgetReference`	`0xC0`	scripted
`patch2NotificationDelay`	`float`	`0xD8`	scripted
`expansionBanner`	`ink.CompoundWidgetReference`	`0xE0`	scripted
`ep1IdName`	`CName`	`0xF8`	scripted
`buttonHintsManagerRef`	`ink.WidgetReference`	`0x100`	scripted
`continuetooltipContainer`	`ink.CompoundWidgetReference`	`0x118`	scripted
`tooltipsManagerRef`	`ink.WidgetReference`	`0x130`	scripted
`versionTextRef`	`ink.TextWidgetReference`	`0x148`	scripted
`eulaWidget`	`ink.WidgetReference`	`0x160`	scripted
`quitGameWidget`	`ink.WidgetReference`	`0x178`	scripted
`sliderWidget`	`ink.WidgetReference`	`0x190`	scripted
`declineButtonWidget`	`ink.WidgetReference`	`0x1A8`	scripted
`acceptButtonWidget`	`ink.WidgetReference`	`0x1C0`	scripted
`declineButtonText`	`ink.TextWidgetReference`	`0x1D8`	scripted
`acceptButtonText`	`ink.TextWidgetReference`	`0x1F0`	scripted
`onlineSystem`	`WeakHandle<game.IOnlineSystem>`	`0x208`	scripted
`requestHandler`	`WeakHandle<ink.ISystemRequestsHandler>`	`0x218`	scripted
`buttonHintsController`	`WeakHandle<ButtonHints>`	`0x228`	scripted
`continueGameTooltipController`	`WeakHandle<ContinueGameTooltip>`	`0x238`	scripted
`expansionHintController`	`WeakHandle<ink.WidgetLogicController>`	`0x248`	scripted
`expansionBannerController`	`WeakHandle<ExpansionBannerController>`	`0x258`	scripted
`accountSelectorController`	`WeakHandle<ink.MenuAccountLogicController>`	`0x268`	scripted
`textAnimController`	`WeakHandle<ink.TextReplaceAnimationController>`	`0x278`	scripted
`tooltipsManager`	`WeakHandle<game.ui.TooltipsManager>`	`0x288`	scripted
`uiSystem`	`game.ui.GameSystemUI?`	`0x298`	scripted
`patchNotesCheckData`	`PatchNotesCheckData?`	`0x2A8`	scripted
`dataSyncStatus`	`services.CloudSavesQueryStatus`	`0x2B8`	scripted
`savesCount`	`int`	`0x2BC`	scripted
`savesReady`	`bool`	`0x2C0`	scripted
`isOffline`	`bool`	`0x2C1`	scripted
`isModded`	`bool`	`0x2C2`	scripted
`isExpansionHintShown`	`bool`	`0x2C3`	scripted
`isMainMenuShownFirstTime`	`bool`	`0x2C4`	scripted
`isPatch2NotificationShown`	`bool`	`0x2C5`	scripted
`isReloadPopupShown`	`bool`	`0x2C6`	scripted
`isEp1Enabled`	`bool`	`0x2C7`	scripted
`gameVersion`	`string`	`0x2C8`	scripted
`patch2NotificationIntroName`	`CName`	`0x2E8`	scripted
`patch2NotificationOutroName`	`CName`	`0x2F0`	scripted
`patch2NotificationAnimProxy`	`ink.anim.Proxy?`	`0x2F8`	scripted
`gameVersionAnim`	`ink.anim.Proxy?`	`0x308`	scripted
`eulaIsAccepted`	`bool`	`0x318`	scripted
`isEulaWindowOpened`	`bool`	`0x319`	scripted
`eulaRead`	`bool`	`0x31A`	scripted
`sliderController`	`WeakHandle<ink.SliderController>`	`0x320`	scripted
`declineButtonController`	`WeakHandle<ink.ButtonController>`	`0x330`	scripted
`acceptButtonController`	`WeakHandle<ink.ButtonController>`	`0x340`	scripted
`eulaAnimationProxy`	`ink.anim.Proxy?`	`0x350`	scripted

Functions

bool OnInitialize() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnInitialize(
    SingleplayerMenuGameController self
);

bool OnUninitialize() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnUninitialize(
    SingleplayerMenuGameController self
);

bool OnSetUserData(IScriptable userData) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnSetUserData",
    (SingleplayerMenuGameController_OnSetUserData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnSetUserData(
    SingleplayerMenuGameController self,
    IScriptable? userData
);

bool OnSetMenuEventDispatcher(WeakHandle<ink.MenuEventDispatcher> menuEventDispatcher) overrideRTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnSetMenuEventDispatcher",
    (SingleplayerMenuGameController_OnSetMenuEventDispatcher x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnSetMenuEventDispatcher(
    SingleplayerMenuGameController self,
    WeakHandle<ink.MenuEventDispatcher> menuEventDispatcher
);

void UpdateExpansionBannerState() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "UpdateExpansionBannerState;",
    (SingleplayerMenuGameController_UpdateExpansionBannerState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_UpdateExpansionBannerState(
    SingleplayerMenuGameController self
);

void SwitchGameLogo(bool isEP1Installed) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "SwitchGameLogo;Bool",
    (SingleplayerMenuGameController_SwitchGameLogo x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_SwitchGameLogo(
    SingleplayerMenuGameController self,
    bool isEP1Installed
);

void OnAdditionalContentPurchaseResult_MainMenu(CName id, bool success) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "OnAdditionalContentPurchaseResult_MainMenu;CNameBool",
    (SingleplayerMenuGameController_OnAdditionalContentPurchaseResult_MainMenu x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnAdditionalContentPurchaseResult_MainMenu(
    SingleplayerMenuGameController self,
    CName id,
    bool success
);

void OnAdditionalContentStatusUpdateResult_MainMenu(CName id, bool success) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "OnAdditionalContentStatusUpdateResult_MainMenu;CNameBool",
    (SingleplayerMenuGameController_OnAdditionalContentStatusUpdateResult_MainMenu x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnAdditionalContentStatusUpdateResult_MainMenu(
    SingleplayerMenuGameController self,
    CName id,
    bool success
);

void OnAdditionalContentInstallationResult_MainMenu(CName id, bool success) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "OnAdditionalContentInstallationResult_MainMenu;CNameBool",
    (SingleplayerMenuGameController_OnAdditionalContentInstallationResult_MainMenu x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnAdditionalContentInstallationResult_MainMenu(
    SingleplayerMenuGameController self,
    CName id,
    bool success
);

void OnAdditionalContentInstallationRequestResult_MainMenu(CName id, bool success) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "OnAdditionalContentInstallationRequestResult_MainMenu;CNameBool",
    (SingleplayerMenuGameController_OnAdditionalContentInstallationRequestResult_MainMenu x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnAdditionalContentInstallationRequestResult_MainMenu(
    SingleplayerMenuGameController self,
    CName id,
    bool success
);

void OnAdditionalContentDataReloadProgress_MainMenu(float progress) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "OnAdditionalContentDataReloadProgress_MainMenu;Float",
    (SingleplayerMenuGameController_OnAdditionalContentDataReloadProgress_MainMenu x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnAdditionalContentDataReloadProgress_MainMenu(
    SingleplayerMenuGameController self,
    float progress
);

void ShowAdditionalDataInvalidError(uint validationResult) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "ShowAdditionalDataInvalidError;Uint32",
    (SingleplayerMenuGameController_ShowAdditionalDataInvalidError x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_ShowAdditionalDataInvalidError(
    SingleplayerMenuGameController self,
    uint validationResult
);

bool OnPurchaseDisabledError(IScriptable userData) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnPurchaseDisabledError",
    (SingleplayerMenuGameController_OnPurchaseDisabledError x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnPurchaseDisabledError(
    SingleplayerMenuGameController self,
    IScriptable? userData
);

bool OnExpansionBannerPressed(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnExpansionBannerPressed",
    (SingleplayerMenuGameController_OnExpansionBannerPressed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnExpansionBannerPressed(
    SingleplayerMenuGameController self,
    ink.PointerEvent? evt
);

void ExpansionBannerInteracted() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "ExpansionBannerInteracted;",
    (SingleplayerMenuGameController_ExpansionBannerInteracted x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_ExpansionBannerInteracted(
    SingleplayerMenuGameController self
);

void OpenExpansionInfoPopup(ExpansionPopupType type, bool forcibly) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "OpenExpansionInfoPopup;ExpansionPopupTypeBool",
    (SingleplayerMenuGameController_OpenExpansionInfoPopup x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OpenExpansionInfoPopup(
    SingleplayerMenuGameController self,
    ExpansionPopupType type,
    bool forcibly
);

bool OnShowOneTimeMessages(IScriptable userData) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnShowOneTimeMessages",
    (SingleplayerMenuGameController_OnShowOneTimeMessages x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnShowOneTimeMessages(
    SingleplayerMenuGameController self,
    IScriptable? userData
);

bool OnCheckPatchNotes(IScriptable userData) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnCheckPatchNotes",
    (SingleplayerMenuGameController_OnCheckPatchNotes x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnCheckPatchNotes(
    SingleplayerMenuGameController self,
    IScriptable? userData
);

void CheckPatchNotes() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "CheckPatchNotes;",
    (SingleplayerMenuGameController_CheckPatchNotes x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_CheckPatchNotes(
    SingleplayerMenuGameController self
);

bool OnOpenPatchNotes(IScriptable userData) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnOpenPatchNotes",
    (SingleplayerMenuGameController_OnOpenPatchNotes x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnOpenPatchNotes(
    SingleplayerMenuGameController self,
    IScriptable? userData
);

bool OnClosePatchNotes(IScriptable userData) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnClosePatchNotes",
    (SingleplayerMenuGameController_OnClosePatchNotes x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnClosePatchNotes(
    SingleplayerMenuGameController self,
    IScriptable? userData
);

bool OnShowMainMenuTooltip(IScriptable userData) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnShowMainMenuTooltip",
    (SingleplayerMenuGameController_OnShowMainMenuTooltip x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnShowMainMenuTooltip(
    SingleplayerMenuGameController self,
    IScriptable? userData
);

bool OnHideMainMenuTooltip(IScriptable userData) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnHideMainMenuTooltip",
    (SingleplayerMenuGameController_OnHideMainMenuTooltip x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnHideMainMenuTooltip(
    SingleplayerMenuGameController self,
    IScriptable? userData
);

bool OnCloseExpansionPopup(IScriptable userData) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnCloseExpansionPopup",
    (SingleplayerMenuGameController_OnCloseExpansionPopup x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnCloseExpansionPopup(
    SingleplayerMenuGameController self,
    IScriptable? userData
);

bool OnPatch2NotificationIntroFinished(ink.anim.Proxy anim) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnPatch2NotificationIntroFinished",
    (SingleplayerMenuGameController_OnPatch2NotificationIntroFinished x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnPatch2NotificationIntroFinished(
    SingleplayerMenuGameController self,
    ink.anim.Proxy? anim
);

bool OnPatch2NotificationOutroFinished(ink.anim.Proxy anim) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnPatch2NotificationOutroFinished",
    (SingleplayerMenuGameController_OnPatch2NotificationOutroFinished x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnPatch2NotificationOutroFinished(
    SingleplayerMenuGameController self,
    ink.anim.Proxy? anim
);

void ShowPatch2Notification() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "ShowPatch2Notification;",
    (SingleplayerMenuGameController_ShowPatch2Notification x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_ShowPatch2Notification(
    SingleplayerMenuGameController self
);

void OpenPatchNotesPopup(bool mode) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "OpenPatchNotesPopup;Bool",
    (SingleplayerMenuGameController_OpenPatchNotesPopup x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OpenPatchNotesPopup(
    SingleplayerMenuGameController self,
    bool mode
);

void SetControlsVisible(bool visible) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "SetControlsVisible;Bool",
    (SingleplayerMenuGameController_SetControlsVisible x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void SetButtonsVisible(bool visible) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "SetButtonsVisible;Bool",
    (SingleplayerMenuGameController_SetButtonsVisible x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool OnRedrawRequested() RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnRedrawRequested",
    (SingleplayerMenuGameController_OnRedrawRequested x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnRedrawRequested(
    SingleplayerMenuGameController self
);

bool OnTooltipContainerSpawned(ink.Widget widget, IScriptable userData) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnTooltipContainerSpawned",
    (SingleplayerMenuGameController_OnTooltipContainerSpawned x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnTooltipContainerSpawned(
    SingleplayerMenuGameController self,
    ink.Widget? widget,
    IScriptable? userData
);

bool OnExpansionHintSpawned(ink.Widget widget, IScriptable userData) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnExpansionHintSpawned",
    (SingleplayerMenuGameController_OnExpansionHintSpawned x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnExpansionHintSpawned(
    SingleplayerMenuGameController self,
    ink.Widget? widget,
    IScriptable? userData
);

bool OnContinueButtonEnter(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnContinueButtonEnter",
    (SingleplayerMenuGameController_OnContinueButtonEnter x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnContinueButtonEnter(
    SingleplayerMenuGameController self,
    ink.PointerEvent? evt
);

bool OnContinueButtonLeave(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnContinueButtonLeave",
    (SingleplayerMenuGameController_OnContinueButtonLeave x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnContinueButtonLeave(
    SingleplayerMenuGameController self,
    ink.PointerEvent? evt
);

bool OnSavesForLoadReady(List saves) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnSavesForLoadReady",
    (SingleplayerMenuGameController_OnSavesForLoadReady x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnSavesForLoadReady(
    SingleplayerMenuGameController self,
    List<string> saves
);

void ShowActionsList() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "ShowActionsList;",
    (SingleplayerMenuGameController_ShowActionsList x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_ShowActionsList(
    SingleplayerMenuGameController self
);

bool OnSaveMetadataReady(ink.SaveMetadataInfo info) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnSaveMetadataReady",
    (SingleplayerMenuGameController_OnSaveMetadataReady x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnSaveMetadataReady(
    SingleplayerMenuGameController self,
    ink.SaveMetadataInfo? info
);

void PopulateMenuItemList() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "PopulateMenuItemList;",
    (SingleplayerMenuGameController_PopulateMenuItemList x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_PopulateMenuItemList(
    SingleplayerMenuGameController self
);

bool OnListRelease(ink.PointerEvent e) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnListRelease",
    (SingleplayerMenuGameController_OnListRelease x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnListRelease(
    SingleplayerMenuGameController self,
    ink.PointerEvent? e
);

bool OnGlobalRelease(ink.PointerEvent e) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnGlobalRelease",
    (SingleplayerMenuGameController_OnGlobalRelease x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnGlobalRelease(
    SingleplayerMenuGameController self,
    ink.PointerEvent? e
);

bool OnRetrySaveDataRequestDelay(RetrySaveDataRequestDelay evt) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnRetrySaveDataRequestDelay",
    (SingleplayerMenuGameController_OnRetrySaveDataRequestDelay x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnRetrySaveDataRequestDelay(
    SingleplayerMenuGameController self,
    RetrySaveDataRequestDelay? evt
);

bool OnGogPressed(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnGogPressed",
    (SingleplayerMenuGameController_OnGogPressed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnGogPressed(
    SingleplayerMenuGameController self,
    ink.PointerEvent? evt
);

bool OnGameVersionPress(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnGameVersionPress",
    (SingleplayerMenuGameController_OnGameVersionPress x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnGameVersionPress(
    SingleplayerMenuGameController self,
    ink.PointerEvent? evt
);

bool OnGameVersionHoverOver(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnGameVersionHoverOver",
    (SingleplayerMenuGameController_OnGameVersionHoverOver x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnGameVersionHoverOver(
    SingleplayerMenuGameController self,
    ink.PointerEvent? evt
);

bool OnGameVersionHoverOut(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnGameVersionHoverOut",
    (SingleplayerMenuGameController_OnGameVersionHoverOut x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnGameVersionHoverOut(
    SingleplayerMenuGameController self,
    ink.PointerEvent? evt
);

bool OnCloudSavesQueryStatusChanged(services.CloudSavesQueryStatus status) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnCloudSavesQueryStatusChanged",
    (SingleplayerMenuGameController_OnCloudSavesQueryStatusChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnCloudSavesQueryStatusChanged(
    SingleplayerMenuGameController self,
    services.CloudSavesQueryStatus status
);

bool OnOnlineStatusChanged(game.OnlineSystemStatus value) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnOnlineStatusChanged",
    (SingleplayerMenuGameController_OnOnlineStatusChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnOnlineStatusChanged(
    SingleplayerMenuGameController self,
    game.OnlineSystemStatus value
);

bool HandleMenuItemActivate(PauseMenuListItemData data) overrideRTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "HandleMenuItemActivate;PauseMenuListItemData",
    (SingleplayerMenuGameController_HandleMenuItemActivate x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_HandleMenuItemActivate(
    SingleplayerMenuGameController self,
    PauseMenuListItemData? data
);

void SpawnExpansionHint() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "SpawnExpansionHint;",
    (SingleplayerMenuGameController_SpawnExpansionHint x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_SpawnExpansionHint(
    SingleplayerMenuGameController self
);

void ShowRussianLanguageDisclaimer() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "ShowRussianLanguageDisclaimer;",
    (SingleplayerMenuGameController_ShowRussianLanguageDisclaimer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_ShowRussianLanguageDisclaimer(
    SingleplayerMenuGameController self
);

void PushErrorPopup(CName title, CName description, uint? errorCode) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "PushErrorPopup;CNameCNameUint32",
    (SingleplayerMenuGameController_PushErrorPopup x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_PushErrorPopup(
    SingleplayerMenuGameController self,
    CName title,
    CName description,
    uint? errorCode
);

void ShowExpansionError(ExpansionErrorType error) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "ShowExpansionError;ExpansionErrorType",
    (SingleplayerMenuGameController_ShowExpansionError x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_ShowExpansionError(
    SingleplayerMenuGameController self,
    ExpansionErrorType error
);

bool OnMarketingConsentPopupTypeResult(ink.MarketingConsentPopupType resultType) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnMarketingConsentPopupTypeResult",
    (SingleplayerMenuGameController_OnMarketingConsentPopupTypeResult x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnMarketingConsentPopupTypeResult(
    SingleplayerMenuGameController self,
    ink.MarketingConsentPopupType resultType
);

void ShowMarketingConsentPopup(ink.MarketingConsentPopupType type) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "ShowMarketingConsentPopup;inkMarketingConsentPopupType",
    (SingleplayerMenuGameController_ShowMarketingConsentPopup x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_ShowMarketingConsentPopup(
    SingleplayerMenuGameController self,
    ink.MarketingConsentPopupType type
);

void ShowSignInPopup() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "ShowSignInPopup;",
    (SingleplayerMenuGameController_ShowSignInPopup x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_ShowSignInPopup(
    SingleplayerMenuGameController self
);

void OnFirstTimeMainMenu() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "OnFirstTimeMainMenu;",
    (SingleplayerMenuGameController_OnFirstTimeMainMenu x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnFirstTimeMainMenu(
    SingleplayerMenuGameController self
);

void DBG_ShowAccountButton() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "DBG_ShowAccountButton;",
    (SingleplayerMenuGameController_DBG_ShowAccountButton x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_DBG_ShowAccountButton(
    SingleplayerMenuGameController self
);

void InitializeAndShowEula() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "InitializeAndShowEula;",
    (SingleplayerMenuGameController_InitializeAndShowEula x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_InitializeAndShowEula(
    SingleplayerMenuGameController self
);

void UninitializeEula() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "UninitializeEula;",
    (SingleplayerMenuGameController_UninitializeEula x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_UninitializeEula(
    SingleplayerMenuGameController self
);

bool OnEulaScrollbarValueChanged(WeakHandle<ink.SliderController> sliderController, float progress, float value) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnEulaScrollbarValueChanged",
    (SingleplayerMenuGameController_OnEulaScrollbarValueChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnEulaScrollbarValueChanged(
    SingleplayerMenuGameController self,
    WeakHandle<ink.SliderController> sliderController,
    float progress,
    float value
);

bool OnDeclineButtonClick(WeakHandle<ink.ButtonController> controller) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnDeclineButtonClick",
    (SingleplayerMenuGameController_OnDeclineButtonClick x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnDeclineButtonClick(
    SingleplayerMenuGameController self,
    WeakHandle<ink.ButtonController> controller
);

void OnDeclineButtonPressed() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "OnDeclineButtonPressed;",
    (SingleplayerMenuGameController_OnDeclineButtonPressed x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnDeclineButtonPressed(
    SingleplayerMenuGameController self
);

bool OnEulaDeclined(ink.anim.Proxy e) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnEulaDeclined",
    (SingleplayerMenuGameController_OnEulaDeclined x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnEulaDeclined(
    SingleplayerMenuGameController self,
    ink.anim.Proxy? e
);

bool OnEulaReopen(ink.anim.Proxy e) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnEulaReopen",
    (SingleplayerMenuGameController_OnEulaReopen x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnEulaReopen(
    SingleplayerMenuGameController self,
    ink.anim.Proxy? e
);

bool OnDeclineButtonStateChanged(WeakHandle<ink.ButtonController> controller, ink.EButtonState oldState, ink.EButtonState newState)

RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnDeclineButtonStateChanged",
    (SingleplayerMenuGameController_OnDeclineButtonStateChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnDeclineButtonStateChanged(
    SingleplayerMenuGameController self,
    WeakHandle<ink.ButtonController> controller,
    ink.EButtonState oldState,
    ink.EButtonState newState
);

bool OnAcceptButtonClick(WeakHandle<ink.ButtonController> controller) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnAcceptButtonClick",
    (SingleplayerMenuGameController_OnAcceptButtonClick x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnAcceptButtonClick(
    SingleplayerMenuGameController self,
    WeakHandle<ink.ButtonController> controller
);

void OnAcceptButtonPressed() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "OnAcceptButtonPressed;",
    (SingleplayerMenuGameController_OnAcceptButtonPressed x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnAcceptButtonPressed(
    SingleplayerMenuGameController self
);

bool OnEulaIsAccepted(ink.anim.Proxy e) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnEulaIsAccepted",
    (SingleplayerMenuGameController_OnEulaIsAccepted x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnEulaIsAccepted(
    SingleplayerMenuGameController self,
    ink.anim.Proxy? e
);

void FinishMenuInitialization() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "FinishMenuInitialization;",
    (SingleplayerMenuGameController_FinishMenuInitialization x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_FinishMenuInitialization(
    SingleplayerMenuGameController self
);

bool OnAcceptButtonStateChanged(WeakHandle<ink.ButtonController> controller, ink.EButtonState oldState, ink.EButtonState newState)

RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnAcceptButtonStateChanged",
    (SingleplayerMenuGameController_OnAcceptButtonStateChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnAcceptButtonStateChanged(
    SingleplayerMenuGameController self,
    WeakHandle<ink.ButtonController> controller,
    ink.EButtonState oldState,
    ink.EButtonState newState
);

bool OnButtonPress(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnButtonPress",
    (SingleplayerMenuGameController_OnButtonPress x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnButtonPress(
    SingleplayerMenuGameController self,
    ink.PointerEvent? evt
);

bool OnAction(game.input.ScriptListenerAction action, game.input.ScriptListenerActionConsumer consumer) RTTI

Generated hook

re.Hooks.Place(
    "SingleplayerMenuGameController",
    "OnAction",
    (SingleplayerMenuGameController_OnAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnAction(
    SingleplayerMenuGameController self,
    game.input.ScriptListenerAction action,
    game.input.ScriptListenerActionConsumer consumer
);