class game.ui

WorldMapMenuGameController

game.ui.WorldMapMenuGameController

81 properties
138 functions

Extends game.ui.MappinsContainerController game.ui.ProjectedHUDGameController game.ui.HUDGameController game.ui.WidgetGameController world.ui.IWidgetGameController ink.IWidgetController IScriptable ISerializable

Properties

Property	Type	Offset
`settingsRecordID`	`TDBID`	`0x4A0`
`selectedMappin`	`WeakHandle<game.ui.BaseWorldMapMappinController>`	`0x368`
`playerOnTop`	`bool`	`0x560`
`entityPreviewLibraryID`	`CName`	`0x4A8`
`entityPreviewSpawnContainer`	`ink.CompoundWidgetReference`	`0x4B0`
`floorPlanSpawnContainer`	`ink.CompoundWidgetReference`	`0x4C8`
`compassWidget`	`ink.WidgetReference`	`0x4E0`
`districtsContainer`	`ink.CompoundWidgetReference`	`0x530`
`subdistrictsContainer`	`ink.CompoundWidgetReference`	`0x548`
`mappinOutlinesContainer`	`ink.CompoundWidgetReference`	`0x568`
`groupOutlinesContainer`	`ink.CompoundWidgetReference`	`0x580`
`tooltipContainer`	`ink.CompoundWidgetReference`	`0x4F8`
`tooltipOffset`	`ink.Margin`	`0x510`
`tooltipDistrictOffset`	`ink.Margin`	`0x520`
`districtView`	`game.ui.EWorldMapDistrictView`	`0x5EC`
`hoveredDistrict`	`game.data.District`	`0x5D8`
`hoveredSubDistrict`	`game.data.District`	`0x5DC`
`selectedDistrict`	`game.data.District`	`0x5E0`
`canChangeCustomFilter`	`bool`	`0x420`
`isZoomToMappinEnabled`	`bool`	`0x3D8`
`delamainTaxiMappinID`	`game.NewMappinID`	`0x3B0`
`preloaderWidget`	`ink.WidgetReference`	`0x60`	scripted
`gameTimeText`	`ink.TextWidgetReference`	`0x78`	scripted
`fastTravelInstructions`	`ink.WidgetReference`	`0x90`	scripted
`delamainTaxiInstructions`	`ink.WidgetReference`	`0xA8`	scripted
`filterSelector`	`ink.WidgetReference`	`0xC0`	scripted
`filterSelectorWarning`	`ink.WidgetReference`	`0xD8`	scripted
`filterText`	`ink.TextWidgetReference`	`0xF0`	scripted
`districtIconImageContainer`	`ink.WidgetReference`	`0x108`	scripted
`districtIconImage`	`ink.ImageWidgetReference`	`0x120`	scripted
`districtNameText`	`ink.TextWidgetReference`	`0x138`	scripted
`subdistrictNameText`	`ink.TextWidgetReference`	`0x150`	scripted
`locationAndGangsContainer`	`ink.WidgetReference`	`0x168`	scripted
`gangsInfoContainer`	`ink.WidgetReference`	`0x180`	scripted
`gangsList`	`ink.CompoundWidgetReference`	`0x198`	scripted
`questContainer`	`ink.WidgetReference`	`0x1B0`	scripted
`questName`	`ink.TextWidgetReference`	`0x1C8`	scripted
`openInJournalButton`	`ink.WidgetReference`	`0x1E0`	scripted
`objectiveName`	`ink.TextWidgetReference`	`0x1F8`	scripted
`objectiveBackground`	`ink.WidgetReference`	`0x210`	scripted
`objectiveFrame`	`ink.WidgetReference`	`0x228`	scripted
`topShadow`	`ink.WidgetReference`	`0x240`	scripted
`rightAxisZoomThreshold`	`float`	`0x258`	scripted
`customFilters`	`ink.WidgetReference`	`0x260`	scripted
`filtersList`	`ink.VerticalPanelWidgetReference`	`0x278`	scripted
`filterLeftArrow`	`ink.WidgetReference`	`0x290`	scripted
`filterRightArrow`	`ink.WidgetReference`	`0x2A8`	scripted
`quickFilterIndicators`	`ink.WidgetReference[]`	`0x2C0`	scripted
`customFiltersListAnimationDelay`	`float`	`0x2D0`	scripted
`cameraMode`	`game.ui.EWorldMapCameraMode`	`0x2D4`	scripted
`menuEventDispatcher`	`WeakHandle<ink.MenuEventDispatcher>`	`0x2D8`	scripted
`tooltipController`	`WeakHandle<WorldMapTooltipContainer>`	`0x2E8`	scripted
`gameTimeTextParams`	`text.TextParameterSet?`	`0x2F8`	scripted
`previousHoveredDistrict`	`game.data.District`	`0x308`	scripted
`currentHoveredDistrict`	`game.data.District`	`0x30C`	scripted
`showedSubdistrictGangs`	`bool`	`0x310`	scripted
`player`	`WeakHandle<game.Object>`	`0x318`	scripted
`audioSystem`	`WeakHandle<game.GameAudioSystem>`	`0x328`	scripted
`journalManager`	`WeakHandle<game.JournalManager>`	`0x338`	scripted
`mappinSystem`	`WeakHandle<game.map.pins.MappinSystem>`	`0x348`	scripted
`mapBlackboard`	`WeakHandle<game.IBlackboard>`	`0x358`	scripted
`mapDefinition`	`UI_MapDef?`	`0x368`	scripted
`trackedObjective`	`WeakHandle<game.JournalQuestObjectiveBase>`	`0x378`	scripted
`trackedQuest`	`WeakHandle<game.JournalQuest>`	`0x388`	scripted
`mappinsPositions`	`Vector3[]`	`0x398`	scripted
`lastRightAxisYAmount`	`float`	`0x3A8`	scripted
`justOpenedQuestJournal`	`bool`	`0x3AC`	scripted
`initMappinFocus`	`MapMenuUserData?`	`0x3B0`	scripted
`currentQuickFilterIndex`	`int`	`0x3C0`	scripted
`currentCustomFilterIndex`	`int`	`0x3C4`	scripted
`spawnedCustomFilterIndex`	`int`	`0x3C8`	scripted
`gangsAsyncSpawnRequests`	`WeakHandle<ink.AsyncSpawnRequest>[]`	`0x3D0`	scripted
`customFiltersList`	`WeakHandle<WorldMapFiltersListItem>[]`	`0x3E0`	scripted
`animationProxy`	`ink.anim.Proxy?`	`0x3F0`	scripted
`entityAttached`	`bool`	`0x400`	scripted
`readyToZoom`	`bool`	`0x401`	scripted
`isHoveringOverFilters`	`bool`	`0x402`	scripted
`isPanning`	`bool`	`0x403`	scripted
`isZooming`	`bool`	`0x404`	scripted
`pressedRMB`	`bool`	`0x405`	scripted
`startedFastTraveling`	`bool`	`0x406`	scripted

Functions

bool IsEntitySetup() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "IsEntitySetup",
    (WorldMapMenuGameController_IsEntitySetup x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool IsEntityAttachedAndSetup() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "IsEntityAttachedAndSetup",
    (WorldMapMenuGameController_IsEntityAttachedAndSetup x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

game.data.WorldMapSettings_Record? GetSettings() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "GetSettings",
    (WorldMapMenuGameController_GetSettings x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.WorldMapSettings_Record>();
    }
);

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

WeakHandle<game.ui.WorldMapPreviewGameController> GetEntityPreview() RTTI

void SetSelectedMappin(game.ui.BaseWorldMapMappinController mappinController) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "SetSelectedMappin",
    (WorldMapMenuGameController_SetSelectedMappin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_SetSelectedMappin(
    game.ui.WorldMapMenuGameController self,
    game.ui.BaseWorldMapMappinController? mappinController
);

bool HasCustomFilter(game.data.WorldMapFilter filter) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "HasCustomFilter",
    (WorldMapMenuGameController_HasCustomFilter x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_HasCustomFilter(
    game.ui.WorldMapMenuGameController self,
    game.data.WorldMapFilter filter
);

uint GetCustomFilters() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "GetCustomFilters",
    (WorldMapMenuGameController_GetCustomFilters x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

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

void SetCustomFilter(game.data.WorldMapFilter filter) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "SetCustomFilter",
    (WorldMapMenuGameController_SetCustomFilter x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_SetCustomFilter(
    game.ui.WorldMapMenuGameController self,
    game.data.WorldMapFilter filter
);

void ClearCustomFilter(game.data.WorldMapFilter filter) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "ClearCustomFilter",
    (WorldMapMenuGameController_ClearCustomFilter x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_ClearCustomFilter(
    game.ui.WorldMapMenuGameController self,
    game.data.WorldMapFilter filter
);

game.data.WorldMapFilter GetQuickFilter() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "GetQuickFilter",
    (WorldMapMenuGameController_GetQuickFilter x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.WorldMapFilter>();
    }
);

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

void SetQuickFilter(game.data.WorldMapFilter filter) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "SetQuickFilter",
    (WorldMapMenuGameController_SetQuickFilter x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_SetQuickFilter(
    game.ui.WorldMapMenuGameController self,
    game.data.WorldMapFilter filter
);

void SetQuickFilterFromRecord(WeakHandle<game.data.MappinUIFilterGroup_Record> filterGroup) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "SetQuickFilterFromRecord",
    (WorldMapMenuGameController_SetQuickFilterFromRecord x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_SetQuickFilterFromRecord(
    game.ui.WorldMapMenuGameController self,
    WeakHandle<game.data.MappinUIFilterGroup_Record> filterGroup
);

void SaveFilters() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "SaveFilters",
    (WorldMapMenuGameController_SaveFilters x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void SetMapCursorEnabled(bool enabled) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "SetMapCursorEnabled",
    (WorldMapMenuGameController_SetMapCursorEnabled x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_SetMapCursorEnabled(
    game.ui.WorldMapMenuGameController self,
    bool enabled
);

void SetFloorPlanVisible() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "SetFloorPlanVisible",
    (WorldMapMenuGameController_SetFloorPlanVisible x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void TrackMappin(game.ui.MappinBaseController mappinController) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "TrackMappin",
    (WorldMapMenuGameController_TrackMappin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_TrackMappin(
    game.ui.WorldMapMenuGameController self,
    game.ui.MappinBaseController? mappinController
);

void UntrackMappin() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "UntrackMappin",
    (WorldMapMenuGameController_UntrackMappin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void TrackCustomPositionMappin() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "TrackCustomPositionMappin",
    (WorldMapMenuGameController_TrackCustomPositionMappin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void TrackDelamainTaxiMappin() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "TrackDelamainTaxiMappin",
    (WorldMapMenuGameController_TrackDelamainTaxiMappin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void UntrackCustomPositionMappin() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "UntrackCustomPositionMappin",
    (WorldMapMenuGameController_UntrackCustomPositionMappin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void UntrackDelamainTaxiMappin() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "UntrackDelamainTaxiMappin",
    (WorldMapMenuGameController_UntrackDelamainTaxiMappin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void ConfirmDelamainTaxiMappinPosition() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "ConfirmDelamainTaxiMappinPosition",
    (WorldMapMenuGameController_ConfirmDelamainTaxiMappinPosition x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void CancelDelamainTaxiMappinPosition() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "CancelDelamainTaxiMappinPosition",
    (WorldMapMenuGameController_CancelDelamainTaxiMappinPosition x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

float GetTravelDistance() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "GetTravelDistance",
    (WorldMapMenuGameController_GetTravelDistance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

void SetMappinVisited(game.ui.BaseWorldMapMappinController mappinController) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "SetMappinVisited",
    (WorldMapMenuGameController_SetMappinVisited x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_SetMappinVisited(
    game.ui.WorldMapMenuGameController self,
    game.ui.BaseWorldMapMappinController? mappinController
);

void MoveToPlayer() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "MoveToPlayer",
    (WorldMapMenuGameController_MoveToPlayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void ZoomToMappin(game.ui.BaseWorldMapMappinController mappinController) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "ZoomToMappin",
    (WorldMapMenuGameController_ZoomToMappin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_ZoomToMappin(
    game.ui.WorldMapMenuGameController self,
    game.ui.BaseWorldMapMappinController? mappinController
);

void ZoomWithMouse(bool zoomIn) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "ZoomWithMouse",
    (WorldMapMenuGameController_ZoomWithMouse x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_ZoomWithMouse(
    game.ui.WorldMapMenuGameController self,
    bool zoomIn
);

void FrameMappinPath(uint hash, float transitionTime, ink.Margin? margin) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "FrameMappinPath",
    (WorldMapMenuGameController_FrameMappinPath x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_FrameMappinPath(
    game.ui.WorldMapMenuGameController self,
    uint hash,
    float transitionTime,
    ink.Margin? margin
);

void SetMousePanEnabled(bool enabled) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "SetMousePanEnabled",
    (WorldMapMenuGameController_SetMousePanEnabled x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_SetMousePanEnabled(
    game.ui.WorldMapMenuGameController self,
    bool enabled
);

void SetMouseRotateEnabled(bool enabled) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "SetMouseRotateEnabled",
    (WorldMapMenuGameController_SetMouseRotateEnabled x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_SetMouseRotateEnabled(
    game.ui.WorldMapMenuGameController self,
    bool enabled
);

bool AreDistrictsVisible() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "AreDistrictsVisible",
    (WorldMapMenuGameController_AreDistrictsVisible x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

float GetCurrentZoom() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "GetCurrentZoom",
    (WorldMapMenuGameController_GetCurrentZoom x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

bool CanDebugTeleport() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "CanDebugTeleport",
    (WorldMapMenuGameController_CanDebugTeleport x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool OnInitialize() RTTI

Generated hook

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

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

bool OnUninitialize() RTTI

Generated hook

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

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

void InitializeQuickFiltersList() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "InitializeQuickFiltersList;",
    (WorldMapMenuGameController_InitializeQuickFiltersList x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool OnFilterLeftArrowClicked(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnFilterLeftArrowClicked",
    (WorldMapMenuGameController_OnFilterLeftArrowClicked x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool OnFilterRightArrowClicked(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnFilterRightArrowClicked",
    (WorldMapMenuGameController_OnFilterRightArrowClicked x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool OnFilterArrowHoverOver(ink.PointerEvent e) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnFilterArrowHoverOver",
    (WorldMapMenuGameController_OnFilterArrowHoverOver x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnFilterArrowHoverOver(
    game.ui.WorldMapMenuGameController self,
    ink.PointerEvent? e
);

bool OnFilterArrowHoverOut(ink.PointerEvent e) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnFilterArrowHoverOut",
    (WorldMapMenuGameController_OnFilterArrowHoverOut x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnFilterArrowHoverOut(
    game.ui.WorldMapMenuGameController self,
    ink.PointerEvent? e
);

bool OnQuickFilterChanged(WeakHandle<game.data.MappinUIFilterGroup_Record> filterGroup) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnQuickFilterChanged",
    (WorldMapMenuGameController_OnQuickFilterChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnQuickFilterChanged(
    game.ui.WorldMapMenuGameController self,
    WeakHandle<game.data.MappinUIFilterGroup_Record> filterGroup
);

void InitializeCustomFiltersList() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "InitializeCustomFiltersList;",
    (WorldMapMenuGameController_InitializeCustomFiltersList x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void UninitializeCustomFiltersList() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "UninitializeCustomFiltersList;",
    (WorldMapMenuGameController_UninitializeCustomFiltersList x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool OnFilterListItemSpawned(ink.Widget filterWidget, IScriptable userData) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnFilterListItemSpawned",
    (WorldMapMenuGameController_OnFilterListItemSpawned x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnFilterListItemSpawned(
    game.ui.WorldMapMenuGameController self,
    ink.Widget? filterWidget,
    IScriptable? userData
);

bool OnFilterSwitched(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnFilterSwitched",
    (WorldMapMenuGameController_OnFilterSwitched x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool OnCustomFilterChanged() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnCustomFilterChanged",
    (WorldMapMenuGameController_OnCustomFilterChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool OnTrackedEntryChanges(uint hash, CName className, game.JournalNotifyOption notifyOption, game.JournalChangeType changeType)

RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnTrackedEntryChanges",
    (WorldMapMenuGameController_OnTrackedEntryChanges x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnTrackedEntryChanges(
    game.ui.WorldMapMenuGameController self,
    uint hash,
    CName className,
    game.JournalNotifyOption notifyOption,
    game.JournalChangeType changeType
);

void PlayCustomFiltersAnimations() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "PlayCustomFiltersAnimations;",
    (WorldMapMenuGameController_PlayCustomFiltersAnimations x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void UpdateTrackedQuest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "UpdateTrackedQuest;",
    (WorldMapMenuGameController_UpdateTrackedQuest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool OnSetUserData(IScriptable userData) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnSetUserData(
    game.ui.WorldMapMenuGameController self,
    IScriptable? userData
);

bool OnRemovePreloader(WeakHandle<ink.Widget> widget) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnRemovePreloader",
    (WorldMapMenuGameController_OnRemovePreloader x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnRemovePreloader(
    game.ui.WorldMapMenuGameController self,
    WeakHandle<ink.Widget> widget
);

bool OnShowSpinner() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnShowSpinner",
    (WorldMapMenuGameController_OnShowSpinner x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool OnEntityAttached() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnEntityAttached",
    (WorldMapMenuGameController_OnEntityAttached x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool OnMapNavigationDelay(MapNavigationDelay evt) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnMapNavigationDelay",
    (WorldMapMenuGameController_OnMapNavigationDelay x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnMapNavigationDelay(
    game.ui.WorldMapMenuGameController self,
    MapNavigationDelay? evt
);

bool OnEntityDetached() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnEntityDetached",
    (WorldMapMenuGameController_OnEntityDetached x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool OnZoomLevelChanged(int oldLevel, int newLevel) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnZoomLevelChanged",
    (WorldMapMenuGameController_OnZoomLevelChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnZoomLevelChanged(
    game.ui.WorldMapMenuGameController self,
    int oldLevel,
    int newLevel
);

bool OnZoomTransitionFinished() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnZoomTransitionFinished",
    (WorldMapMenuGameController_OnZoomTransitionFinished x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool OnZoomToMappinEnabledChanged(bool flag) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnZoomToMappinEnabledChanged",
    (WorldMapMenuGameController_OnZoomToMappinEnabledChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnZoomToMappinEnabledChanged(
    game.ui.WorldMapMenuGameController self,
    bool flag
);

bool OnCanChangeCustomFilterChanged(bool flag) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnCanChangeCustomFilterChanged",
    (WorldMapMenuGameController_OnCanChangeCustomFilterChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnCanChangeCustomFilterChanged(
    game.ui.WorldMapMenuGameController self,
    bool flag
);

bool OnSelectedMappinChanged(game.ui.BaseWorldMapMappinController oldController, game.ui.BaseWorldMapMappinController newController)

RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnSelectedMappinChanged",
    (WorldMapMenuGameController_OnSelectedMappinChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnSelectedMappinChanged(
    game.ui.WorldMapMenuGameController self,
    game.ui.BaseWorldMapMappinController? oldController,
    game.ui.BaseWorldMapMappinController? newController
);

bool OnSetZoomLevelEvent(SetZoomLevelEvent eventData) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnSetZoomLevelEvent",
    (WorldMapMenuGameController_OnSetZoomLevelEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnSetZoomLevelEvent(
    game.ui.WorldMapMenuGameController self,
    SetZoomLevelEvent? eventData
);

bool OnHoverOverMappin(ink.PointerEvent e) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnHoverOverMappin",
    (WorldMapMenuGameController_OnHoverOverMappin x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnHoverOverMappin(
    game.ui.WorldMapMenuGameController self,
    ink.PointerEvent? e
);

bool OnHoverOutMappin(ink.PointerEvent e) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnHoverOutMappin",
    (WorldMapMenuGameController_OnHoverOutMappin x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnHoverOutMappin(
    game.ui.WorldMapMenuGameController self,
    ink.PointerEvent? e
);

CName GetDistrictAnimation(game.ui.EWorldMapDistrictView view, bool show) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "GetDistrictAnimation;gameuiEWorldMapDistrictViewBool",
    (WorldMapMenuGameController_GetDistrictAnimation x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_GetDistrictAnimation(
    game.ui.WorldMapMenuGameController self,
    game.ui.EWorldMapDistrictView view,
    bool show
);

bool OnDistrictViewChanged(game.ui.EWorldMapDistrictView oldView, game.ui.EWorldMapDistrictView newView) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnDistrictViewChanged",
    (WorldMapMenuGameController_OnDistrictViewChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnDistrictViewChanged(
    game.ui.WorldMapMenuGameController self,
    game.ui.EWorldMapDistrictView oldView,
    game.ui.EWorldMapDistrictView newView
);

bool OnUpdateHoveredDistricts(game.data.District district, game.data.District subdistrict) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnUpdateHoveredDistricts",
    (WorldMapMenuGameController_OnUpdateHoveredDistricts x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnUpdateHoveredDistricts(
    game.ui.WorldMapMenuGameController self,
    game.data.District district,
    game.data.District subdistrict
);

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

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnSetMenuEventDispatcher(
    game.ui.WorldMapMenuGameController self,
    WeakHandle<ink.MenuEventDispatcher> menuEventDispatcher
);

bool OnBack(IScriptable userData) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnBack",
    (WorldMapMenuGameController_OnBack x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnBack(
    game.ui.WorldMapMenuGameController self,
    IScriptable? userData
);

void CycleQuickFilterPrev() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "CycleQuickFilterPrev;",
    (WorldMapMenuGameController_CycleQuickFilterPrev x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void CycleQuickFilterNext() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "CycleQuickFilterNext;",
    (WorldMapMenuGameController_CycleQuickFilterNext x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void UpdateFastTravelVisiblity(bool fastTravelEnabled) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "UpdateFastTravelVisiblity;Bool",
    (WorldMapMenuGameController_UpdateFastTravelVisiblity x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_UpdateFastTravelVisiblity(
    game.ui.WorldMapMenuGameController self,
    bool fastTravelEnabled
);

void UpdateDelamainTaxiVisiblity(bool delamainTaxiEnabled) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "UpdateDelamainTaxiVisiblity;Bool",
    (WorldMapMenuGameController_UpdateDelamainTaxiVisiblity x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_UpdateDelamainTaxiVisiblity(
    game.ui.WorldMapMenuGameController self,
    bool delamainTaxiEnabled
);

void NavigateCustomFilters(ECustomFilterDPadNavigationOption option) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "NavigateCustomFilters;ECustomFilterDPadNavigationOption",
    (WorldMapMenuGameController_NavigateCustomFilters x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_NavigateCustomFilters(
    game.ui.WorldMapMenuGameController self,
    ECustomFilterDPadNavigationOption option
);

void CycleWorldMapFilter(bool cycleNext) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "CycleWorldMapFilter;Bool",
    (WorldMapMenuGameController_CycleWorldMapFilter x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_CycleWorldMapFilter(
    game.ui.WorldMapMenuGameController self,
    bool cycleNext
);

void SetQuickFilterIndicator(int index) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "SetQuickFilterIndicator;Int32",
    (WorldMapMenuGameController_SetQuickFilterIndicator x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_SetQuickFilterIndicator(
    game.ui.WorldMapMenuGameController self,
    int index
);

void ToggleQuickFilterIndicatorsVsibility(bool toggle) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "ToggleQuickFilterIndicatorsVsibility;Bool",
    (WorldMapMenuGameController_ToggleQuickFilterIndicatorsVsibility x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_ToggleQuickFilterIndicatorsVsibility(
    game.ui.WorldMapMenuGameController self,
    bool toggle
);

void OpenSelectedQuest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "OpenSelectedQuest;",
    (WorldMapMenuGameController_OpenSelectedQuest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool CanOpenCodexPopup(WeakHandle<game.map.pins.IMappin> mappin) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "CanOpenCodexPopup;IMappin",
    (WorldMapMenuGameController_CanOpenCodexPopup x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_CanOpenCodexPopup(
    game.ui.WorldMapMenuGameController self,
    WeakHandle<game.map.pins.IMappin> mappin
);

WeakHandle<game.JournalEntry> GetCodexEntryForMappin(WeakHandle<game.map.pins.IMappin> mappin) RTTI

void OpenCodexPopup(WeakHandle<game.JournalEntry> jurnalEntry) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "OpenCodexPopup;JournalEntry",
    (WorldMapMenuGameController_OpenCodexPopup x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OpenCodexPopup(
    game.ui.WorldMapMenuGameController self,
    WeakHandle<game.JournalEntry> jurnalEntry
);

void OpenTrackedQuest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "OpenTrackedQuest;",
    (WorldMapMenuGameController_OpenTrackedQuest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void OpenQuestInJournal(WeakHandle<game.JournalEntry> questEntry) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "OpenQuestInJournal;JournalEntry",
    (WorldMapMenuGameController_OpenQuestInJournal x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OpenQuestInJournal(
    game.ui.WorldMapMenuGameController self,
    WeakHandle<game.JournalEntry> questEntry
);

void UpdateCustomFilter(game.data.WorldMapFilter filter, bool enable) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "UpdateCustomFilter;gamedataWorldMapFilterBool",
    (WorldMapMenuGameController_UpdateCustomFilter x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_UpdateCustomFilter(
    game.ui.WorldMapMenuGameController self,
    game.data.WorldMapFilter filter,
    bool enable
);

void SetMappinIconsVisible(bool visible) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "SetMappinIconsVisible;Bool",
    (WorldMapMenuGameController_SetMappinIconsVisible x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_SetMappinIconsVisible(
    game.ui.WorldMapMenuGameController self,
    bool visible
);

void UpdateGameTime() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "UpdateGameTime;",
    (WorldMapMenuGameController_UpdateGameTime x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void TryFastTravel() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "TryFastTravel;",
    (WorldMapMenuGameController_TryFastTravel x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool TryConfirmDelamainTaxi() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "TryConfirmDelamainTaxi;",
    (WorldMapMenuGameController_TryConfirmDelamainTaxi x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void PrepFastTravel() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "PrepFastTravel;",
    (WorldMapMenuGameController_PrepFastTravel x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void TryTrackQuestOrSetWaypoint() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "TryTrackQuestOrSetWaypoint;",
    (WorldMapMenuGameController_TryTrackQuestOrSetWaypoint x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void TrackQuestMappin(game.ui.MappinBaseController controller) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "TrackQuestMappin;BaseMappinBaseController",
    (WorldMapMenuGameController_TrackQuestMappin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_TrackQuestMappin(
    game.ui.WorldMapMenuGameController self,
    game.ui.MappinBaseController? controller
);

void UpdateTravelDestination() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "UpdateTravelDestination;",
    (WorldMapMenuGameController_UpdateTravelDestination x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetTravelCost() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "GetTravelCost;",
    (WorldMapMenuGameController_GetTravelCost x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

void FastTravel() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "FastTravel;",
    (WorldMapMenuGameController_FastTravel x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void DEBUG_Teleport() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "DEBUG_Teleport;",
    (WorldMapMenuGameController_DEBUG_Teleport x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void HandleAxisInput(ink.PointerEvent e) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "HandleAxisInput;inkPointerEvent",
    (WorldMapMenuGameController_HandleAxisInput x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_HandleAxisInput(
    game.ui.WorldMapMenuGameController self,
    ink.PointerEvent? e
);

void HandlePressInput(ink.PointerEvent e) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "HandlePressInput;inkPointerEvent",
    (WorldMapMenuGameController_HandlePressInput x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_HandlePressInput(
    game.ui.WorldMapMenuGameController self,
    ink.PointerEvent? e
);

void HandleReleaseInput(ink.PointerEvent e) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "HandleReleaseInput;inkPointerEvent",
    (WorldMapMenuGameController_HandleReleaseInput x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_HandleReleaseInput(
    game.ui.WorldMapMenuGameController self,
    ink.PointerEvent? e
);

void HandleHoldInput(ink.PointerEvent e) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "HandleHoldInput;inkPointerEvent",
    (WorldMapMenuGameController_HandleHoldInput x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_HandleHoldInput(
    game.ui.WorldMapMenuGameController self,
    ink.PointerEvent? e
);

bool OnPressInput(ink.PointerEvent e) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnPressInput",
    (WorldMapMenuGameController_OnPressInput x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnPressInput(
    game.ui.WorldMapMenuGameController self,
    ink.PointerEvent? e
);

bool OnReleaseInput(ink.PointerEvent e) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnReleaseInput",
    (WorldMapMenuGameController_OnReleaseInput x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnReleaseInput(
    game.ui.WorldMapMenuGameController self,
    ink.PointerEvent? e
);

bool OnHoldInput(ink.PointerEvent e) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnHoldInput",
    (WorldMapMenuGameController_OnHoldInput x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnHoldInput(
    game.ui.WorldMapMenuGameController self,
    ink.PointerEvent? e
);

bool OnAxisInput(ink.PointerEvent e) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnAxisInput",
    (WorldMapMenuGameController_OnAxisInput x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnAxisInput(
    game.ui.WorldMapMenuGameController self,
    ink.PointerEvent? e
);

bool IsPoliceTooltip(game.data.MappinVariant mappinVariant) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "IsPoliceTooltip;gamedataMappinVariant",
    (WorldMapMenuGameController_IsPoliceTooltip x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_IsPoliceTooltip(
    game.ui.WorldMapMenuGameController self,
    game.data.MappinVariant mappinVariant
);

bool ShouldDisplayInHud(game.data.MappinVariant mappinVariant) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "ShouldDisplayInHud;gamedataMappinVariant",
    (WorldMapMenuGameController_ShouldDisplayInHud x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_ShouldDisplayInHud(
    game.ui.WorldMapMenuGameController self,
    game.data.MappinVariant mappinVariant
);

WorldMapTooltipType GetTooltipType(game.data.MappinVariant mappinVariant) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "GetTooltipType;gamedataMappinVariant",
    (WorldMapMenuGameController_GetTooltipType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.WorldMapTooltipType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_GetTooltipType(
    game.ui.WorldMapMenuGameController self,
    game.data.MappinVariant mappinVariant
);

void ShowMappinTooltip(WeakHandle<game.ui.BaseWorldMapMappinController> controller) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "ShowMappinTooltip;BaseWorldMapMappinController",
    (WorldMapMenuGameController_ShowMappinTooltip x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_ShowMappinTooltip(
    game.ui.WorldMapMenuGameController self,
    WeakHandle<game.ui.BaseWorldMapMappinController> controller
);

void HideMappinTooltip(WeakHandle<game.ui.BaseWorldMapMappinController> controller) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "HideMappinTooltip;BaseWorldMapMappinController",
    (WorldMapMenuGameController_HideMappinTooltip x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_HideMappinTooltip(
    game.ui.WorldMapMenuGameController self,
    WeakHandle<game.ui.BaseWorldMapMappinController> controller
);

void ShowGangsInfo(game.data.District district, game.data.District sub) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "ShowGangsInfo;gamedataDistrictgamedataDistrict",
    (WorldMapMenuGameController_ShowGangsInfo x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_ShowGangsInfo(
    game.ui.WorldMapMenuGameController self,
    game.data.District district,
    game.data.District sub
);

void ClearAllAsyncSpawnRequests() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "ClearAllAsyncSpawnRequests;",
    (WorldMapMenuGameController_ClearAllAsyncSpawnRequests x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool OnGangListItemSpawned(ink.Widget gangWidget, IScriptable userData) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "OnGangListItemSpawned",
    (WorldMapMenuGameController_OnGangListItemSpawned x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_OnGangListItemSpawned(
    game.ui.WorldMapMenuGameController self,
    ink.Widget? gangWidget,
    IScriptable? userData
);

void HideAllTooltips() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "HideAllTooltips;",
    (WorldMapMenuGameController_HideAllTooltips x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void UpdateTooltip(WorldMapTooltipType tooltipType, WeakHandle<game.ui.BaseWorldMapMappinController> controller) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "UpdateTooltip;WorldMapTooltipTypeBaseWorldMapMappinController",
    (WorldMapMenuGameController_UpdateTooltip x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_UpdateTooltip(
    game.ui.WorldMapMenuGameController self,
    WorldMapTooltipType tooltipType,
    WeakHandle<game.ui.BaseWorldMapMappinController> controller
);

void UpdateSelectedMappinTooltip() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "UpdateSelectedMappinTooltip;",
    (WorldMapMenuGameController_UpdateSelectedMappinTooltip x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool CanOpenJournalForMappin(WeakHandle<game.map.pins.IMappin> mappin) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "CanOpenJournalForMappin;IMappin",
    (WorldMapMenuGameController_CanOpenJournalForMappin x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_CanOpenJournalForMappin(
    game.ui.WorldMapMenuGameController self,
    WeakHandle<game.map.pins.IMappin> mappin
);

void RefreshInputHints() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "RefreshInputHints;",
    (WorldMapMenuGameController_RefreshInputHints x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void AddInputHintUpdate(out game.ui.UpdateInputHintMultipleEvent evt, bool show, CName action, string locKey, out int priority)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameuiWorldMapMenuGameController",
    "AddInputHintUpdate;UpdateInputHintMultipleEventBoolCNamescript_ref<String>Int32",
    (WorldMapMenuGameController_AddInputHintUpdate x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_AddInputHintUpdate(
    game.ui.WorldMapMenuGameController self,
    game.ui.UpdateInputHintMultipleEvent? evt,
    bool show,
    CName action,
    string locKey,
    int priority
);

game.ui.MappinUIProfile CreateMappinUIProfile(WeakHandle<game.map.pins.IMappin> mappin, game.data.MappinVariant mappinVariant, game.ui.MappinControllerCustomData customData)

overrideRTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "CreateMappinUIProfile;IMappingamedataMappinVariantMappinControllerCustomData",
    (WorldMapMenuGameController_CreateMappinUIProfile x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ui.MappinUIProfile>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_CreateMappinUIProfile(
    game.ui.WorldMapMenuGameController self,
    WeakHandle<game.map.pins.IMappin> mappin,
    game.data.MappinVariant mappinVariant,
    game.ui.MappinControllerCustomData? customData
);

WeakHandle<game.Object> GetPlayer() RTTI
WeakHandle<game.JournalManager> GetJournalManager() RTTI

int GetTotalZoomLevels() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "GetTotalZoomLevels;",
    (WorldMapMenuGameController_GetTotalZoomLevels x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

FastTravelSystem? GetFastTravelSystem() RTTI

Generated hook

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

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

bool IsFastTravelEnabled() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "IsFastTravelEnabled;",
    (WorldMapMenuGameController_IsFastTravelEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

DelamainTaxiSystem? GetDelamainTaxiSystem() RTTI

Generated hook

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

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

bool IsDelamainTaxiEnabled() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "IsDelamainTaxiEnabled;",
    (WorldMapMenuGameController_IsDelamainTaxiEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

game.Object? GetOwner() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "GetOwner;",
    (WorldMapMenuGameController_GetOwner x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameObject>();
    }
);

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

bool HasSelectedMappin() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "HasSelectedMappin;",
    (WorldMapMenuGameController_HasSelectedMappin x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool HasSelectedDelamainTaxiMappin() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "HasSelectedDelamainTaxiMappin;",
    (WorldMapMenuGameController_HasSelectedDelamainTaxiMappin x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

game.JournalEntry? GetMappinJournalEntry(game.map.pins.IMappin mappin) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "GetMappinJournalEntry;IMappin",
    (WorldMapMenuGameController_GetMappinJournalEntry x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.JournalEntry>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_GetMappinJournalEntry(
    game.ui.WorldMapMenuGameController self,
    game.map.pins.IMappin? mappin
);

uint GetMappinJournalPathHash(game.map.pins.IMappin mappin) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "GetMappinJournalPathHash;IMappin",
    (WorldMapMenuGameController_GetMappinJournalPathHash x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_GetMappinJournalPathHash(
    game.ui.WorldMapMenuGameController self,
    game.map.pins.IMappin? mappin
);

bool CanQuestTrackMappin(WeakHandle<game.map.pins.IMappin> mappin) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "CanQuestTrackMappin;IMappin",
    (WorldMapMenuGameController_CanQuestTrackMappin x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_CanQuestTrackMappin(
    game.ui.WorldMapMenuGameController self,
    WeakHandle<game.map.pins.IMappin> mappin
);

bool CanQuestTrackMappin(WeakHandle<game.ui.BaseWorldMapMappinController> controller) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "CanQuestTrackMappin;BaseWorldMapMappinController",
    (WorldMapMenuGameController_CanQuestTrackMappin2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_CanQuestTrackMappin2(
    game.ui.WorldMapMenuGameController self,
    WeakHandle<game.ui.BaseWorldMapMappinController> controller
);

bool IsMappinQuestTracked(WeakHandle<game.map.pins.IMappin> mappin) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "IsMappinQuestTracked;IMappin",
    (WorldMapMenuGameController_IsMappinQuestTracked x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_IsMappinQuestTracked(
    game.ui.WorldMapMenuGameController self,
    WeakHandle<game.map.pins.IMappin> mappin
);

bool IsMappinQuestTracked(WeakHandle<game.ui.BaseWorldMapMappinController> controller) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "IsMappinQuestTracked;BaseWorldMapMappinController",
    (WorldMapMenuGameController_IsMappinQuestTracked2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_IsMappinQuestTracked2(
    game.ui.WorldMapMenuGameController self,
    WeakHandle<game.ui.BaseWorldMapMappinController> controller
);

bool CanPlayerTrackMappin(WeakHandle<game.map.pins.IMappin> mappin) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "CanPlayerTrackMappin;IMappin",
    (WorldMapMenuGameController_CanPlayerTrackMappin x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_CanPlayerTrackMappin(
    game.ui.WorldMapMenuGameController self,
    WeakHandle<game.map.pins.IMappin> mappin
);

bool CanPlayerTrackMappin(WeakHandle<game.ui.BaseWorldMapMappinController> controller) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "CanPlayerTrackMappin;BaseWorldMapMappinController",
    (WorldMapMenuGameController_CanPlayerTrackMappin2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_CanPlayerTrackMappin2(
    game.ui.WorldMapMenuGameController self,
    WeakHandle<game.ui.BaseWorldMapMappinController> controller
);

bool CanZoomToMappin(WeakHandle<game.ui.BaseWorldMapMappinController> controller) RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "CanZoomToMappin;BaseWorldMapMappinController",
    (WorldMapMenuGameController_CanZoomToMappin x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct WorldMapMenuGameController_CanZoomToMappin(
    game.ui.WorldMapMenuGameController self,
    WeakHandle<game.ui.BaseWorldMapMappinController> controller
);

bool CanPay() RTTI

Generated hook

re.Hooks.Place(
    "gameuiWorldMapMenuGameController",
    "CanPay;",
    (WorldMapMenuGameController_CanPay x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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