class

SingleplayerMenuGameController

70 properties
95 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
`gogContainerRef`	`ink.CompoundWidgetReference`	`0x90`	scripted
`gogUserDisplayContainerRef`	`ink.WidgetReference`	`0xA8`	scripted
`AdditionalButtonsBoxRef`	`ink.CompoundWidgetReference`	`0xC0`	scripted
`accountSelector`	`ink.CompoundWidgetReference`	`0xD8`	scripted
`commonGameVersionButton`	`ink.CompoundWidgetReference`	`0xF0`	scripted
`emporiumButtons`	`ink.CompoundWidgetReference`	`0x108`	scripted
`emporiumGameVersionButton`	`ink.CompoundWidgetReference`	`0x120`	scripted
`emporiumFeaturesBtn`	`ink.CompoundWidgetReference`	`0x138`	scripted
`patch2Notification`	`ink.CompoundWidgetReference`	`0x150`	scripted
`patch2NotificationDelay`	`float`	`0x168`	scripted
`expansionBanner`	`ink.CompoundWidgetReference`	`0x170`	scripted
`ep1IdName`	`CName`	`0x188`	scripted
`eulaWidget`	`ink.WidgetReference`	`0x190`	scripted
`quitGameWidget`	`ink.WidgetReference`	`0x1A8`	scripted
`sliderWidget`	`ink.WidgetReference`	`0x1C0`	scripted
`declineButtonWidget`	`ink.WidgetReference`	`0x1D8`	scripted
`acceptButtonWidget`	`ink.WidgetReference`	`0x1F0`	scripted
`declineButtonText`	`ink.TextWidgetReference`	`0x208`	scripted
`acceptButtonText`	`ink.TextWidgetReference`	`0x220`	scripted
`contentTextRef`	`ink.TextWidgetReference`	`0x238`	scripted
`contentTextLocKey`	`CName`	`0x250`	scripted
`buttonHintsManagerRef`	`ink.WidgetReference`	`0x258`	scripted
`continuetooltipContainer`	`ink.CompoundWidgetReference`	`0x270`	scripted
`tooltipsManagerRef`	`ink.WidgetReference`	`0x288`	scripted
`versionTextRef`	`ink.TextWidgetReference`	`0x2A0`	scripted
`onlineSystem`	`WeakHandle<game.IOnlineSystem>`	`0x2B8`	scripted
`requestHandler`	`WeakHandle<ink.ISystemRequestsHandler>`	`0x2C8`	scripted
`buttonHintsController`	`WeakHandle<ButtonHints>`	`0x2D8`	scripted
`continueGameTooltipController`	`WeakHandle<ContinueGameTooltip>`	`0x2E8`	scripted
`modioTooltipController`	`WeakHandle<ModioToolTipInMenu>`	`0x2F8`	scripted
`expansionHintController`	`WeakHandle<TrophyTooltipController>`	`0x308`	scripted
`expansionBannerController`	`WeakHandle<ExpansionBannerController>`	`0x318`	scripted
`accountSelectorController`	`WeakHandle<ink.MenuAccountLogicController>`	`0x328`	scripted
`gogContainerController`	`WeakHandle<GogContainerController>`	`0x338`	scripted
`textAnimController`	`WeakHandle<ink.TextReplaceAnimationController>`	`0x348`	scripted
`tooltipsManager`	`WeakHandle<game.ui.TooltipsManager>`	`0x358`	scripted
`gameVersionButton`	`ink.CompoundWidgetReference`	`0x368`	scripted
`uiSystem`	`game.ui.GameSystemUI?`	`0x380`	scripted
`patchNotesCheckData`	`PatchNotesCheckData?`	`0x390`	scripted
`dataSyncStatus`	`services.CloudSavesQueryStatus`	`0x3A0`	scripted
`savesCount`	`int`	`0x3A4`	scripted
`savesReady`	`bool`	`0x3A8`	scripted
`isOffline`	`bool`	`0x3A9`	scripted
`isModded`	`bool`	`0x3AA`	scripted
`isUserUGCRestricted`	`bool`	`0x3AB`	scripted
`isExpansionHintShown`	`bool`	`0x3AC`	scripted
`isMainMenuShownFirstTime`	`bool`	`0x3AD`	scripted
`isPatch2NotificationShown`	`bool`	`0x3AE`	scripted
`isReloadPopupShown`	`bool`	`0x3AF`	scripted
`isEp1Enabled`	`bool`	`0x3B0`	scripted
`isEmporium`	`bool`	`0x3B1`	scripted
`gameVersion`	`string`	`0x3B8`	scripted
`patch2NotificationIntroName`	`CName`	`0x3D8`	scripted
`patch2NotificationOutroName`	`CName`	`0x3E0`	scripted
`patch2NotificationAnimProxy`	`ink.anim.Proxy?`	`0x3E8`	scripted
`gameVersionAnim`	`ink.anim.Proxy?`	`0x3F8`	scripted
`eulaIsAccepted`	`bool`	`0x408`	scripted
`isEulaWindowOpened`	`bool`	`0x409`	scripted
`eulaRead`	`bool`	`0x40A`	scripted
`sliderController`	`WeakHandle<ink.SliderController>`	`0x410`	scripted
`declineButtonController`	`WeakHandle<ink.ButtonController>`	`0x420`	scripted
`acceptButtonController`	`WeakHandle<ink.ButtonController>`	`0x430`	scripted
`eulaAnimationProxy`	`ink.anim.Proxy?`	`0x440`	scripted
`modioButton`	`WeakHandle<ink.Widget>`	`0x450`	scripted
`isModReloadingPopupShown`	`bool`	`0x460`	scripted
`hasAlreadyShownMenuItemList`	`bool`	`0x461`	scripted
`gogUserDisplayController`	`WeakHandle<GogUserDisplayController>`	`0x468`	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 OnPlayerAttach(game.Object playerPuppet) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnPlayerAttach(
    SingleplayerMenuGameController self,
    game.Object? playerPuppet
);

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
);

bool OnRequestRestrictionStatusCallBack(int status) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnRequestRestrictionStatusCallBack(
    SingleplayerMenuGameController self,
    int status
);

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
);

void OpenModReloadingPopup() RTTI

Generated hook

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

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

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 OpenStartupCheckPopup(ink.ModToUpdateInfo[] modInfoList, bool bHaveDeletedModsBeenRemoved, bool bShouldDisplayThumbnail, bool bShouldDisplayModName, bool bModsDefaultSelected)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "OpenStartupCheckPopup;array<ModToUpdateInfo>BoolBoolBoolBool",
    (SingleplayerMenuGameController_OpenStartupCheckPopup x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OpenStartupCheckPopup(
    SingleplayerMenuGameController self,
    ink.ModToUpdateInfo[] modInfoList,
    bool bHaveDeletedModsBeenRemoved,
    bool bShouldDisplayThumbnail,
    bool bShouldDisplayModName,
    bool bModsDefaultSelected
);

void OpenUpdateModsPopup(ink.ModToUpdateInfo[] modInfoList, int deprecatedCount, bool bDoesNumberExceedModLimit, bool bHaveDeletedModsBeenRemoved, bool bShouldDisplayThumbnail, bool bShouldDisplayModName, bool bModsDefaultSelected)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "OpenUpdateModsPopup;array<ModToUpdateInfo>Int32BoolBoolBoolBoolBool",
    (SingleplayerMenuGameController_OpenUpdateModsPopup x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OpenUpdateModsPopup(
    SingleplayerMenuGameController self,
    ink.ModToUpdateInfo[] modInfoList,
    int deprecatedCount,
    bool bDoesNumberExceedModLimit,
    bool bHaveDeletedModsBeenRemoved,
    bool bShouldDisplayThumbnail,
    bool bShouldDisplayModName,
    bool bModsDefaultSelected
);

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
);

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

Generated hook

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

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

bool OnModioButtonEnter(ink.PointerEvent evt) RTTI

Generated hook

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

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

bool OnModioButtonLeave(ink.PointerEvent evt) RTTI

Generated hook

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

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

bool OnShowModioTerms(IScriptable userData) RTTI

Generated hook

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

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

void ShowModioTerms() RTTI

Generated hook

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

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

bool OnModioTermsPopupClose(ModioTermsPopupCloseEvent evt) RTTI

Generated hook

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

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

void RefreshModioToolTipPos() RTTI

Generated hook

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

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

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
);

bool isAbleToDisplayBrokenTrophyIconAndTooltip() RTTI

Generated hook

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

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

void DisplayAndSetupTrophyIcon(WeakHandle<PauseMenuButtonItem> inButtonItem, bool bIsContinueButton) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "DisplayAndSetupTrophyIcon;PauseMenuButtonItemBool",
    (SingleplayerMenuGameController_DisplayAndSetupTrophyIcon x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_DisplayAndSetupTrophyIcon(
    SingleplayerMenuGameController self,
    WeakHandle<PauseMenuButtonItem> inButtonItem,
    bool bIsContinueButton
);

bool OnTrophyIconHoveredForContinue(ink.PointerEvent e) RTTI

Generated hook

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

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

bool OnTrophyIconHoveredForNewGame(ink.PointerEvent e) RTTI

Generated hook

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

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

bool OnTrophyIconHoveredOut(ink.PointerEvent e) RTTI

Generated hook

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

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

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 OnGogReloadEmporium(GogReloadEmporium evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnGogReloadEmporium(
    SingleplayerMenuGameController self,
    GogReloadEmporium? 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 OnEmporiumFeaturesPress(ink.PointerEvent evt) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_OnEmporiumFeaturesPress(
    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
);

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 CheckEmporiumPopup() RTTI

Generated hook

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

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

void ShowEmporiumPopup() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_ShowEmporiumPopup(
    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 ShowEula() RTTI

Generated hook

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

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

void ShowPitchScreen() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_ShowPitchScreen(
    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
);

void PlatformUsernameReceived(string platformName) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "SingleplayerMenuGameController",
    "PlatformUsernameReceived;String",
    (SingleplayerMenuGameController_PlatformUsernameReceived x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct SingleplayerMenuGameController_PlatformUsernameReceived(
    SingleplayerMenuGameController self,
    string platformName
);

bool OnGogSignIn() RTTI

Generated hook

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

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

bool OnDisconnectClickedEvent(DisconnectClickedEvent evt) RTTI

Generated hook

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

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