class

RadialWheelController

32 properties
61 functions

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

Properties

Property	Type	Offset
`radialWeapons`	`WeaponRadialSlot?[]`	`0x58`	scripted
`inputHintController`	`RadialSlot?`	`0x68`	scripted
`activeSlotTooltip`	`RadialSlot?`	`0x78`	scripted
`activeWeaponSlotTooltip`	`RadialSlot?`	`0x88`	scripted
`statusEffects`	`RadialSlot?`	`0x98`	scripted
`pointerRef`	`ink.WidgetReference`	`0xA8`	scripted
`activeSlot`	`WeaponRadialSlot?`	`0xC0`	scripted
`pointer`	`WeakHandle<PointerController>`	`0xD0`	scripted
`activeIndex`	`int`	`0xE0`	scripted
`initialized`	`bool`	`0xE4`	scripted
`isActive`	`bool`	`0xE5`	scripted
`pendingRadialSlotAsyncSpawnCount`	`int`	`0xE8`	scripted
`consSlotCachedData`	`game.InventoryItemData`	`0xF0`	scripted
`gadgetSlotCachedData`	`game.InventoryItemData`	`0x350`	scripted
`cyclingActionRegistered`	`CName`	`0x5B0`	scripted
`registeredInputHints`	`game.ui.InputHintData[]`	`0x5B8`	scripted
`applyInputHint`	`game.ui.InputHintData`	`0x5C8`	scripted
`cycleInputHintDataLeft`	`game.ui.InputHintData`	`0x620`	scripted
`cycleInputHintDataRight`	`game.ui.InputHintData`	`0x678`	scripted
`radialMode`	`ERadialMode`	`0x6D0`	scripted
`inventoryManager`	`InventoryDataManagerV2?`	`0x6D8`	scripted
`equipmentSystem`	`WeakHandle<EquipmentSystem>`	`0x6E8`	scripted
`transactionSystem`	`WeakHandle<game.TransactionSystem>`	`0x6F8`	scripted
`quickSlotBlackboard`	`WeakHandle<game.IBlackboard>`	`0x708`	scripted
`QuickSlotBlackboardDef`	`UI_QuickSlotsDataDef?`	`0x718`	scripted
`axisInputCallbackID`	`red.CallbackObject?`	`0x728`	scripted
`UISystemBB`	`WeakHandle<game.IBlackboard>`	`0x738`	scripted
`UISystemDef`	`UI_SystemDef?`	`0x748`	scripted
`isInMenuCallbackID`	`red.CallbackObject?`	`0x758`	scripted
`equipmentUIBlackboard`	`WeakHandle<game.IBlackboard>`	`0x768`	scripted
`EquipmentBlackboardDef`	`UI_EquipmentDef?`	`0x778`	scripted
`equipmentUICallbackID`	`red.CallbackObject?`	`0x788`	scripted

Functions

void HandleEquipmentChangeByTask(SPaperdollEquipData eqData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "HandleEquipmentChangeByTask;script_ref<SPaperdollEquipData>",
    (RadialWheelController_HandleEquipmentChangeByTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_HandleEquipmentChangeByTask(
    RadialWheelController self,
    SPaperdollEquipData eqData
);

void HandleEquipmentChangeTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "HandleEquipmentChangeTask;ScriptTaskData",
    (RadialWheelController_HandleEquipmentChangeTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_HandleEquipmentChangeTask(
    RadialWheelController self,
    game.ScriptTaskData? data
);

bool OnInitialize() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnInitialize(
    RadialWheelController self
);

bool OnLateInit(LateInit evt) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "OnLateInit",
    (RadialWheelController_OnLateInit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnLateInit(
    RadialWheelController self,
    LateInit? evt
);

bool OnUninitialize() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnUninitialize(
    RadialWheelController self
);

void RegisterBlackboards(bool shouldRegister) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "RegisterBlackboards;Bool",
    (RadialWheelController_RegisterBlackboards x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_RegisterBlackboards(
    RadialWheelController self,
    bool shouldRegister
);

void Shutdown() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "Shutdown;",
    (RadialWheelController_Shutdown x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_Shutdown(
    RadialWheelController self
);

void SendPSMRadialCloseRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "SendPSMRadialCloseRequest;",
    (RadialWheelController_SendPSMRadialCloseRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_SendPSMRadialCloseRequest(
    RadialWheelController self
);

void UpdateRequired() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "UpdateRequired;",
    (RadialWheelController_UpdateRequired x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_UpdateRequired(
    RadialWheelController self
);

int GetValidNeighbouringIndex(game.InventoryItemData[] arr, int fromIndex, bool searchNext) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "GetValidNeighbouringIndex;script_ref<array<InventoryItemData>>Int32Bool",
    (RadialWheelController_GetValidNeighbouringIndex x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_GetValidNeighbouringIndex(
    RadialWheelController self,
    game.InventoryItemData[] arr,
    int fromIndex,
    bool searchNext
);

void CacheData() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "CacheData;",
    (RadialWheelController_CacheData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_CacheData(
    RadialWheelController self
);

void CacheInputHintData() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "CacheInputHintData;",
    (RadialWheelController_CacheInputHintData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_CacheInputHintData(
    RadialWheelController self
);

Vector2 ConvertMarginToVector(ink.Margin margin) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "ConvertMarginToVector;inkMargin",
    (RadialWheelController_ConvertMarginToVector x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector2>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_ConvertMarginToVector(
    RadialWheelController self,
    ink.Margin margin
);

WeaponRadialSlot? DetermineActiveSlot(float angle) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "DetermineActiveSlot;Float",
    (RadialWheelController_DetermineActiveSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.WeaponRadialSlot>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_DetermineActiveSlot(
    RadialWheelController self,
    float angle
);

bool SetActiveSlot(WeaponRadialSlot newActiveSlot) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "SetActiveSlot;WeaponRadialSlot",
    (RadialWheelController_SetActiveSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_SetActiveSlot(
    RadialWheelController self,
    WeaponRadialSlot? newActiveSlot
);

bool IsGadgetOrConsumableSlot(WeaponRadialSlot slot) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "IsGadgetOrConsumableSlot;WeaponRadialSlot",
    (RadialWheelController_IsGadgetOrConsumableSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_IsGadgetOrConsumableSlot(
    RadialWheelController self,
    WeaponRadialSlot? slot
);

float ConvertVectorToAngle(Vector4 input) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "ConvertVectorToAngle;Vector4",
    (RadialWheelController_ConvertVectorToAngle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_ConvertVectorToAngle(
    RadialWheelController self,
    Vector4 input
);

void SpawnRadialWeapons() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "SpawnRadialWeapons;",
    (RadialWheelController_SpawnRadialWeapons x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_SpawnRadialWeapons(
    RadialWheelController self
);

bool SpawnSlotWidget(RadialSlot slot) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "SpawnSlotWidget;RadialSlot",
    (RadialWheelController_SpawnSlotWidget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_SpawnSlotWidget(
    RadialWheelController self,
    RadialSlot? slot
);

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

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "OnSlotWidgetSpawned",
    (RadialWheelController_OnSlotWidgetSpawned x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void SetupWidgetForSlot(ink.Widget widget, RadialSlot slot) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "SetupWidgetForSlot;inkWidgetRadialSlot",
    (RadialWheelController_SetupWidgetForSlot x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_SetupWidgetForSlot(
    RadialWheelController self,
    ink.Widget? widget,
    RadialSlot? slot
);

void RefreshSlots() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "RefreshSlots;",
    (RadialWheelController_RefreshSlots x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_RefreshSlots(
    RadialWheelController self
);

void RefreshWeapons() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "RefreshWeapons;",
    (RadialWheelController_RefreshWeapons x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_RefreshWeapons(
    RadialWheelController self
);

void RefreshHotkeys() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "RefreshHotkeys;",
    (RadialWheelController_RefreshHotkeys x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_RefreshHotkeys(
    RadialWheelController self
);

void RefreshHotkey(CyclableRadialSlot slot) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "RefreshHotkey;CyclableRadialSlot",
    (RadialWheelController_RefreshHotkey x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_RefreshHotkey(
    RadialWheelController self,
    CyclableRadialSlot? slot
);

void RefreshCyberware() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "RefreshCyberware;",
    (RadialWheelController_RefreshCyberware x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_RefreshCyberware(
    RadialWheelController self
);

bool BindItem(CyclableRadialSlot slot, EHotkeyRequestType requestType) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "BindItem;CyclableRadialSlotEHotkeyRequestType",
    (RadialWheelController_BindItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_BindItem(
    RadialWheelController self,
    CyclableRadialSlot? slot,
    EHotkeyRequestType requestType
);

bool DrawItem(RadialSlot slot) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "DrawItem;RadialSlot",
    (RadialWheelController_DrawItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_DrawItem(
    RadialWheelController self,
    RadialSlot? slot
);

void ApplySlot(RadialSlot slot) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "ApplySlot;RadialSlot",
    (RadialWheelController_ApplySlot x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_ApplySlot(
    RadialWheelController self,
    RadialSlot? slot
);

void DisarmPlayer() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "DisarmPlayer;",
    (RadialWheelController_DisarmPlayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_DisarmPlayer(
    RadialWheelController self
);

void CycleSlot(CyclableRadialSlot cyclableSlot, CName actionName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "CycleSlot;CyclableRadialSlotCName",
    (RadialWheelController_CycleSlot x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_CycleSlot(
    RadialWheelController self,
    CyclableRadialSlot? cyclableSlot,
    CName actionName
);

void CycleHotkeys(CyclableRadialSlot cyclableSlot, bool next) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "CycleHotkeys;CyclableRadialSlotBool",
    (RadialWheelController_CycleHotkeys x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_CycleHotkeys(
    RadialWheelController self,
    CyclableRadialSlot? cyclableSlot,
    bool next
);

void CycleCyberware(CyclableRadialSlot cyclableSlot) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "CycleCyberware;CyclableRadialSlot",
    (RadialWheelController_CycleCyberware x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_CycleCyberware(
    RadialWheelController self,
    CyclableRadialSlot? cyclableSlot
);

void UpdatePointer(Vector4 rawInputVector, float rawAngle) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "UpdatePointer;Vector4Float",
    (RadialWheelController_UpdatePointer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_UpdatePointer(
    RadialWheelController self,
    Vector4 rawInputVector,
    float rawAngle
);

void UpdateStatusEffects() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "UpdateStatusEffects;",
    (RadialWheelController_UpdateStatusEffects x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_UpdateStatusEffects(
    RadialWheelController self
);

void UpdateActiveTooltip() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "UpdateActiveTooltip;",
    (RadialWheelController_UpdateActiveTooltip x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_UpdateActiveTooltip(
    RadialWheelController self
);

void RestoreCachedSlots() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "RestoreCachedSlots;",
    (RadialWheelController_RestoreCachedSlots x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_RestoreCachedSlots(
    RadialWheelController self
);

void ClearInputHints() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "ClearInputHints;",
    (RadialWheelController_ClearInputHints x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_ClearInputHints(
    RadialWheelController self
);

void UpdateInputHints() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "UpdateInputHints;",
    (RadialWheelController_UpdateInputHints x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_UpdateInputHints(
    RadialWheelController self
);

void AddInputHint(game.ui.InputHintData inputHint, bool add) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "AddInputHint;script_ref<InputHintData>Bool",
    (RadialWheelController_AddInputHint x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_AddInputHint(
    RadialWheelController self,
    game.ui.InputHintData inputHint,
    bool add
);

void SendInputHintEvent(game.ui.InputHintData inputHint, bool show) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "SendInputHintEvent;script_ref<InputHintData>Bool",
    (RadialWheelController_SendInputHintEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_SendInputHintEvent(
    RadialWheelController self,
    game.ui.InputHintData inputHint,
    bool show
);

bool OnOpenWheelRequest(QuickSlotButtonHoldStartEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "OnOpenWheelRequest",
    (RadialWheelController_OnOpenWheelRequest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnOpenWheelRequest(
    RadialWheelController self,
    QuickSlotButtonHoldStartEvent? evt
);

bool OnForceRadialWheelShutdown(ForceRadialWheelShutdown evt) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "OnForceRadialWheelShutdown",
    (RadialWheelController_OnForceRadialWheelShutdown x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnForceRadialWheelShutdown(
    RadialWheelController self,
    ForceRadialWheelShutdown? evt
);

bool OnForceRadialWheelRebuild(ForceRadialWheelRebuild evt) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "OnForceRadialWheelRebuild",
    (RadialWheelController_OnForceRadialWheelRebuild x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnForceRadialWheelRebuild(
    RadialWheelController self,
    ForceRadialWheelRebuild? evt
);

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

Generated hook

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

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

bool OnRadialAngleChanged(Vector4 v) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "OnRadialAngleChanged",
    (RadialWheelController_OnRadialAngleChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnRadialAngleChanged(
    RadialWheelController self,
    Vector4 v
);

bool OnIsInMenuChanged(bool param) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "OnIsInMenuChanged",
    (RadialWheelController_OnIsInMenuChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_OnIsInMenuChanged(
    RadialWheelController self,
    bool param
);

void HandleEquipmentChange(SPaperdollEquipData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RadialWheelController",
    "HandleEquipmentChange;script_ref<SPaperdollEquipData>",
    (RadialWheelController_HandleEquipmentChange x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_HandleEquipmentChange(
    RadialWheelController self,
    SPaperdollEquipData data
);

InventoryItemDisplayController? GetController(RadialSlot slot) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "GetController;RadialSlot",
    (RadialWheelController_GetController x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.InventoryItemDisplayController>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_GetController(
    RadialWheelController self,
    RadialSlot? slot
);

bool CanPlayerCycleCyberware() RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "CanPlayerCycleCyberware;",
    (RadialWheelController_CanPlayerCycleCyberware x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_CanPlayerCycleCyberware(
    RadialWheelController self
);

game.InventoryItemData[] GetValidItemsForMiscSlot(CyclableRadialSlot cyclableSlot) RTTI

bool CanPlayerCycleMisc(CyclableRadialSlot cyclableSlot) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "CanPlayerCycleMisc;CyclableRadialSlot",
    (RadialWheelController_CanPlayerCycleMisc x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_CanPlayerCycleMisc(
    RadialWheelController self,
    CyclableRadialSlot? cyclableSlot
);

bool CanPlayerCycleSlot(CyclableRadialSlot slot) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "CanPlayerCycleSlot;CyclableRadialSlot",
    (RadialWheelController_CanPlayerCycleSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_CanPlayerCycleSlot(
    RadialWheelController self,
    CyclableRadialSlot? slot
);

WeakHandle<game.ItemData>[] GetWeapons() RTTI

game.InventoryItemData GetValidCombatCyberware() RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "GetValidCombatCyberware;",
    (RadialWheelController_GetValidCombatCyberware x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.InventoryItemData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_GetValidCombatCyberware(
    RadialWheelController self
);

game.InventoryItemData GetBaseFists() RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "GetBaseFists;",
    (RadialWheelController_GetBaseFists x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.InventoryItemData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_GetBaseFists(
    RadialWheelController self
);

WeakHandle<EquipmentSystem> GetEquipmentSystem() RTTI
WeakHandle<game.ItemData> GetItemData(game.ItemID itemID) RTTI

game.InventoryItemData GetInventoryItemData(RadialSlot slot) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "GetInventoryItemData;RadialSlot",
    (RadialWheelController_GetInventoryItemData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.InventoryItemData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_GetInventoryItemData(
    RadialWheelController self,
    RadialSlot? slot
);

game.ItemID GetItemID(RadialSlot slot) RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "GetItemID;RadialSlot",
    (RadialWheelController_GetItemID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_GetItemID(
    RadialWheelController self,
    RadialSlot? slot
);

game.Object? GetPlayer() RTTI

Generated hook

re.Hooks.Place(
    "RadialWheelController",
    "GetPlayer;",
    (RadialWheelController_GetPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RadialWheelController_GetPlayer(
    RadialWheelController self
);