class

RipperDocGameController

154 properties
154 functions

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

Properties

Property	Type	Offset
`TooltipsManagerRef`	`ink.WidgetReference`	`0x10`	scripted
`buttonHintsManagerRef`	`ink.WidgetReference`	`0x28`	scripted
`animationControllerContainer`	`ink.WidgetReference`	`0x40`	scripted
`armsAnchor`	`ink.CompoundWidgetReference`	`0x58`	scripted
`legsAnchor`	`ink.CompoundWidgetReference`	`0x70`	scripted
`handsAnchor`	`ink.CompoundWidgetReference`	`0x88`	scripted
`systemAnchor`	`ink.CompoundWidgetReference`	`0xA0`	scripted
`nervousAnchor`	`ink.CompoundWidgetReference`	`0xB8`	scripted
`skeletonAnchor`	`ink.CompoundWidgetReference`	`0xD0`	scripted
`ocularCortexAnchor`	`ink.CompoundWidgetReference`	`0xE8`	scripted
`integumentaryAnchor`	`ink.CompoundWidgetReference`	`0x100`	scripted
`frontalCortexAnchor`	`ink.CompoundWidgetReference`	`0x118`	scripted
`cardiovascularAnchor`	`ink.CompoundWidgetReference`	`0x130`	scripted
`minigridTargetAnchor`	`ink.CompoundWidgetReference`	`0x148`	scripted
`minigridTargetAnchorMargin`	`ink.Margin`	`0x160`	scripted
`minigridSelectorLeftAnchor`	`ink.CompoundWidgetReference`	`0x170`	scripted
`minigridSelectorRightAnchor`	`ink.CompoundWidgetReference`	`0x188`	scripted
`minigridSelectorLeftAnchorMargin`	`ink.Margin`	`0x1A0`	scripted
`minigridSelectorRightAnchorMargin`	`ink.Margin`	`0x1B0`	scripted
`tooltipLeftAnchor`	`ink.WidgetReference`	`0x1C0`	scripted
`tooltipRightAnchor`	`ink.WidgetReference`	`0x1D8`	scripted
`upgradeResourcesAnchor`	`ink.CompoundWidgetReference`	`0x1F0`	scripted
`upgradeCWInputName`	`CName`	`0x208`	scripted
`upgradeResourcesContainerMaxWidth`	`float`	`0x210`	scripted
`allocationPointContainerDefault`	`ink.CompoundWidgetReference`	`0x218`	scripted
`inventoryViewAnchor`	`ink.CompoundWidgetReference`	`0x230`	scripted
`selectorAnchor`	`ink.CompoundWidgetReference`	`0x248`	scripted
`inventoryWarnning`	`ink.WidgetReference`	`0x260`	scripted
`maleEyeAndMaskBinkAnimation`	`ink.VideoWidgetReference`	`0x278`	scripted
`femaleEyeAndMaskBinkAnimation`	`ink.VideoWidgetReference`	`0x290`	scripted
`c_maleOcular`	`red.ResourceReferenceScriptToken`	`0x2A8`	scripted
`c_femaleOcular`	`red.ResourceReferenceScriptToken`	`0x2B0`	scripted
`c_maleMask`	`red.ResourceReferenceScriptToken`	`0x2B8`	scripted
`c_femaleMask`	`red.ResourceReferenceScriptToken`	`0x2C0`	scripted
`minigridSetPositionAnimationSpeed`	`float`	`0x2C8`	scripted
`minigridSetPositionAnimInterpolationType`	`ink.anim.InterpolationType`	`0x2CC`	scripted
`minigridSetPositionAnimInterpolationMode`	`ink.anim.InterpolationMode`	`0x2CD`	scripted
`minigridIntroAnimationSpeed`	`float`	`0x2D0`	scripted
`minigridIntroAnimInterpolationType`	`ink.anim.InterpolationType`	`0x2D4`	scripted
`minigridIntroAnimInterpolationMode`	`ink.anim.InterpolationMode`	`0x2D5`	scripted
`capacityTutorialAnchor`	`ink.WidgetReference`	`0x2D8`	scripted
`armorTutorialAnchor`	`ink.WidgetReference`	`0x2F0`	scripted
`slotsTutorialAnchor`	`ink.WidgetReference`	`0x308`	scripted
`vikTutorial`	`bool`	`0x320`	scripted
`isTutorial`	`bool`	`0x321`	scripted
`ep1StandaloneTutorial`	`bool`	`0x322`	scripted
`mq048TutorialFact`	`bool`	`0x323`	scripted
`isReturningPlayer`	`bool`	`0x324`	scripted
`tutorialEyesCW`	`TDBID`	`0x328`	scripted
`tutorialHandsCW`	`TDBID`	`0x330`	scripted
`tutorialArmorCW`	`TDBID`	`0x338`	scripted
`tutorialZeroCapacityModifier`	`game.StatModifierData_Deprecated?`	`0x340`	scripted
`perkBarCapacity`	`game.data.NewPerkType`	`0x350`	scripted
`perkBarArmor`	`game.data.NewPerkType`	`0x354`	scripted
`perkSlotSkeleton`	`game.data.NewPerkType`	`0x358`	scripted
`perkSlotHands`	`game.data.NewPerkType`	`0x35C`	scripted
`ripperdocHoverState`	`RipperdocHoverState`	`0x360`	scripted
`screen`	`CyberwareScreenType`	`0x364`	scripted
`filterMode`	`RipperdocModes`	`0x368`	scripted
`player`	`WeakHandle<PlayerPuppet>`	`0x370`	scripted
`audioSystem`	`WeakHandle<game.GameAudioSystem>`	`0x380`	scripted
`uiSystem`	`WeakHandle<game.ui.GameSystemUI>`	`0x390`	scripted
`questSystem`	`WeakHandle<quest.QuestsSystem>`	`0x3A0`	scripted
`playerID`	`ent.EntityID`	`0x3B0`	scripted
`InventoryManager`	`InventoryDataManagerV2?`	`0x3B8`	scripted
`uiScriptableSystem`	`WeakHandle<UIScriptableSystem>`	`0x3C8`	scripted
`uiInventorySystem`	`WeakHandle<UIInventoryScriptableSystem>`	`0x3D8`	scripted
`menuEventDispatcher`	`WeakHandle<ink.MenuEventDispatcher>`	`0x3E8`	scripted
`ripperdocTokenManager`	`RipperdocTokenManager?`	`0x3F8`	scripted
`categories`	`RipperdocCategory[]`	`0x408`	scripted
`TooltipsManager`	`WeakHandle<game.ui.TooltipsManager>`	`0x418`	scripted
`defaultTooltipsMargin`	`ink.Margin`	`0x428`	scripted
`defaultTooltipGap`	`float`	`0x438`	scripted
`VendorBlackboard`	`WeakHandle<game.IBlackboard>`	`0x440`	scripted
`equipmentBlackboard`	`WeakHandle<game.IBlackboard>`	`0x450`	scripted
`equipmentBlackboardCallback`	`red.CallbackObject?`	`0x460`	scripted
`tokenBlackboard`	`WeakHandle<game.IBlackboard>`	`0x470`	scripted
`tokenBlackboardCallback`	`red.CallbackObject?`	`0x480`	scripted
`inventoryView`	`WeakHandle<RipperdocInventoryController>`	`0x490`	scripted
`selector`	`WeakHandle<RipperdocSelectorController>`	`0x4A0`	scripted
`dollHoverArea`	`game.data.EquipmentArea`	`0x4B0`	scripted
`dollSelected`	`bool`	`0x4B4`	scripted
`hoverArea`	`game.data.EquipmentArea`	`0x4B5`	scripted
`filterArea`	`game.data.EquipmentArea`	`0x4B9`	scripted
`lastAreaVisited`	`game.data.EquipmentArea`	`0x4BD`	scripted
`filteringByArea`	`bool`	`0x4C1`	scripted
`isInEquipPopup`	`bool`	`0x4C2`	scripted
`isInventoryOpen`	`bool`	`0x4C3`	scripted
`allFilters`	`game.data.EquipmentArea[]`	`0x4C8`	scripted
`cachedAvailableItemsCounters`	`int[]`	`0x4D8`	scripted
`cachedVendorItemsCounters`	`int[]`	`0x4E8`	scripted
`cachedPlayerItemsCounters`	`int[]`	`0x4F8`	scripted
`vendorItems`	`ink.ScriptHashMap?`	`0x648`	scripted
`vendorWrappedItems`	`ink.ScriptHashMap?`	`0x658`	scripted
`soldItemsCache`	`SoldItemsCache?`	`0x668`	scripted
`craftingMaterialsListItems`	`WeakHandle<CrafringMaterialItemController>[]`	`0x678`	scripted
`upgradeHoldFinished`	`bool`	`0x688`	scripted
`commonCraftingMaterials`	`CachedCraftingMaterial?[]`	`0x690`	scripted
`equipmentMinigrids`	`WeakHandle<CyberwareInventoryMiniGrid>[]`	`0x6A0`	scripted
`isActivePanel`	`bool`	`0x6D8`	scripted
`hasEquipEventTriggered`	`bool`	`0x6D9`	scripted
`hasUnequipEventTriggered`	`bool`	`0x6DA`	scripted
`statsSystem`	`WeakHandle<game.StatsSystem>`	`0x6E0`	scripted
`statsDataSystem`	`WeakHandle<game.StatsDataSystem>`	`0x6F0`	scripted
`statusEffectSystem`	`WeakHandle<game.StatusEffectSystem>`	`0x700`	scripted
`inventorySystem`	`WeakHandle<game.InventoryManager>`	`0x710`	scripted
`isPurchased`	`bool`	`0x720`	scripted
`isPurchasing`	`bool`	`0x721`	scripted
`isPurchaseEquip`	`bool`	`0x722`	scripted
`isUpgrading`	`bool`	`0x723`	scripted
`previewMinigrid`	`WeakHandle<CyberwareInventoryMiniGrid>`	`0x728`	scripted
`equippedSlotIndex`	`int`	`0x738`	scripted
`isMusculoskeletalUpgrade3Unlocked`	`bool`	`0x73C`	scripted
`handleItemEquippedNextFrameRequested`	`bool`	`0x73D`	scripted
`handleItemEquippedOnItemAdded`	`TDBID`	`0x740`	scripted
`inventoryListener`	`game.InventoryScriptListener?`	`0x748`	scripted
`tokenPopup`	`ink.GameNotificationToken?`	`0x758`	scripted
`playerItemDisplayContext`	`ItemDisplayContextData?`	`0x768`	scripted
`vendorItemDisplayContext`	`ItemDisplayContextData?`	`0x778`	scripted
`inventoryRefreshRequested`	`bool`	`0x788`	scripted
`invalidateMinigridsRequested`	`bool`	`0x789`	scripted
`upgradeData`	`RipperdocTokenPopupData?`	`0x790`	scripted
`vendorUserData`	`VendorUserData?`	`0x7A0`	scripted
`VendorDataManager`	`VendorDataManager?`	`0x7B0`	scripted
`buttonHintsController`	`WeakHandle<ButtonHints>`	`0x7C0`	scripted
`soldItemsFetched`	`bool`	`0x7D0`	scripted
`animationController`	`WeakHandle<RipperdocScreenAnimationController>`	`0x7D8`	scripted
`isHoveringOverUpgradableSlot`	`bool`	`0x7E8`	scripted
`upgradeQuality`	`game.data.Quality`	`0x7E9`	scripted
`upgradeCostData`	`CyberwareUpgradeCostData`	`0x7F0`	scripted
`upgradeItem`	`game.data.Item_Record?`	`0x800`	scripted
`hoveredItem`	`WeakHandle<UIInventoryItem>`	`0x810`	scripted
`hoveredItemDisplay`	`WeakHandle<InventoryItemDisplayController>`	`0x820`	scripted
`pulse`	`PulseAnimation?`	`0x830`	scripted
`anim`	`ink.anim.Proxy?`	`0x840`	scripted
`developmentDataManager`	`PlayerDevelopmentDataManager?`	`0x850`	scripted
`capacityHoverEvent`	`RipperdocMeterCapacityHoverEvent?`	`0x860`	scripted
`capacityApplyEvent`	`RipperdocMeterCapacityApplyEvent?`	`0x870`	scripted
`armorHoverEvent`	`RipperdocMeterArmorHoverEvent?`	`0x880`	scripted
`armorApplyEvent`	`RipperdocMeterArmorApplyEvent?`	`0x890`	scripted
`maxCapacityPossible`	`float`	`0x8A0`	scripted
`capacityBarintroAnimProxy`	`ink.anim.Proxy?`	`0x8A8`	scripted
`armorBarintroAnimProxy`	`ink.anim.Proxy?`	`0x8B8`	scripted
`armorAttunemendDescription`	`string`	`0x8C8`	scripted
`armorAttunemendDescription2`	`string`	`0x8E8`	scripted
`armorMultBonusDescription`	`string`	`0x908`	scripted
`isArmorBarReady`	`bool`	`0x928`	scripted
`isCapacityBarReady`	`bool`	`0x929`	scripted
`capacityPerk1Bought`	`bool`	`0x92A`	scripted
`capacityPerk2Bought`	`bool`	`0x92B`	scripted
`armorPerk1Bought`	`bool`	`0x92C`	scripted
`armorCWEquipedNum`	`int`	`0x930`	scripted
`cameFromInventoryMenu`	`bool`	`0x934`	scripted
`screenDisplayContext`	`ScreenDisplayContext`	`0x935`	scripted

Functions

bool OnSetUserData(IScriptable userData) RTTI

Generated hook

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

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

bool CheckTokenAvailability() RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "CheckTokenAvailability;",
    (RipperDocGameController_CheckTokenAvailability x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_CheckTokenAvailability(
    RipperDocGameController self
);

bool OnInitialize() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnInitialize(
    RipperDocGameController self
);

bool OnUIVendorAttachedEvent(UIVendorAttachedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnUIVendorAttachedEvent",
    (RipperDocGameController_OnUIVendorAttachedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnUIVendorAttachedEvent(
    RipperDocGameController self,
    UIVendorAttachedEvent? evt
);

TDBID GetAppropriateHandsTutorialCyberware(game.data.Quality itemQuality) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "GetAppropriateHandsTutorialCyberware;gamedataQuality",
    (RipperDocGameController_GetAppropriateHandsTutorialCyberware x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetAppropriateHandsTutorialCyberware(
    RipperDocGameController self,
    game.data.Quality itemQuality
);

float UnequipAllFromGrid(game.data.EquipmentArea equipmentArea, float? requiredCapacity) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "UnequipAllFromGrid;gamedataEquipmentAreaFloat",
    (RipperDocGameController_UnequipAllFromGrid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_UnequipAllFromGrid(
    RipperDocGameController self,
    game.data.EquipmentArea equipmentArea,
    float? requiredCapacity
);

float FreeUpTheCapacityForTutorial(float capacity) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "FreeUpTheCapacityForTutorial;Float",
    (RipperDocGameController_FreeUpTheCapacityForTutorial x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_FreeUpTheCapacityForTutorial(
    RipperDocGameController self,
    float capacity
);

void InitFacePaperdoll() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "InitFacePaperdoll;",
    (RipperDocGameController_InitFacePaperdoll x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_InitFacePaperdoll(
    RipperDocGameController self
);

bool ShouldMaskPaperdollBeVisible() RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "ShouldMaskPaperdollBeVisible;",
    (RipperDocGameController_ShouldMaskPaperdollBeVisible x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_ShouldMaskPaperdollBeVisible(
    RipperDocGameController self
);

void InventoryModeWarnning(bool show) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "InventoryModeWarnning;Bool",
    (RipperDocGameController_InventoryModeWarnning x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_InventoryModeWarnning(
    RipperDocGameController self,
    bool show
);

bool OnWarnningHidden(ink.anim.Proxy anim) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnWarnningHidden",
    (RipperDocGameController_OnWarnningHidden x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

string GetAreaHeader(game.data.EquipmentArea area) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "GetAreaHeader;gamedataEquipmentArea",
    (RipperDocGameController_GetAreaHeader x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetAreaHeader(
    RipperDocGameController self,
    game.data.EquipmentArea area
);

void StartCWUpgrade() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "StartCWUpgrade;",
    (RipperDocGameController_StartCWUpgrade x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_StartCWUpgrade(
    RipperDocGameController self
);

void HighlightUpgradeResources(WeakHandle<UIInventoryItem> item, bool isVendorItem) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "HighlightUpgradeResources;UIInventoryItemBool",
    (RipperDocGameController_HighlightUpgradeResources x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_HighlightUpgradeResources(
    RipperDocGameController self,
    WeakHandle<UIInventoryItem> item,
    bool isVendorItem
);

void UnhighlightUpgradeResources() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "UnhighlightUpgradeResources;",
    (RipperDocGameController_UnhighlightUpgradeResources x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_UnhighlightUpgradeResources(
    RipperDocGameController self
);

void PopulateCraftingMaterials() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "PopulateCraftingMaterials;",
    (RipperDocGameController_PopulateCraftingMaterials x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_PopulateCraftingMaterials(
    RipperDocGameController self
);

void CreateCraftingMaterialItem(CachedCraftingMaterial craftingMaterial, ink.CompoundWidgetReference gridList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "CreateCraftingMaterialItem;CachedCraftingMaterialinkCompoundRef",
    (RipperDocGameController_CreateCraftingMaterialItem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_CreateCraftingMaterialItem(
    RipperDocGameController self,
    CachedCraftingMaterial? craftingMaterial,
    ink.CompoundWidgetReference gridList
);

bool OnCraftingMaterialItemSpawned(ink.Widget widget, BackpackCraftingMaterialItemCallbackData callbackData) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnCraftingMaterialItemSpawned",
    (RipperDocGameController_OnCraftingMaterialItemSpawned x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnCraftingMaterialItemSpawned(
    RipperDocGameController self,
    ink.Widget? widget,
    BackpackCraftingMaterialItemCallbackData? callbackData
);

bool OnCraftingMaterialHoverOver(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnCraftingMaterialHoverOver",
    (RipperDocGameController_OnCraftingMaterialHoverOver x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool OnCraftingMaterialHoverOut(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnCraftingMaterialHoverOut",
    (RipperDocGameController_OnCraftingMaterialHoverOut x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void UpdateCraftingMaterial(TDBID materialTweakDBID, bool? skipAnim) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "UpdateCraftingMaterial;TweakDBIDBool",
    (RipperDocGameController_UpdateCraftingMaterial x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_UpdateCraftingMaterial(
    RipperDocGameController self,
    TDBID materialTweakDBID,
    bool? skipAnim
);

void CheckCraftingMaterialContainerOverflow() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "CheckCraftingMaterialContainerOverflow;",
    (RipperDocGameController_CheckCraftingMaterialContainerOverflow x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_CheckCraftingMaterialContainerOverflow(
    RipperDocGameController self
);

bool OnReleaseInput(ink.PointerEvent e) RTTI

Generated hook

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

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

void OpenPerkTree() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "OpenPerkTree;",
    (RipperDocGameController_OpenPerkTree x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OpenPerkTree(
    RipperDocGameController self
);

void ShowActionBlockedRightNowNotification() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "ShowActionBlockedRightNowNotification;",
    (RipperDocGameController_ShowActionBlockedRightNowNotification x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_ShowActionBlockedRightNowNotification(
    RipperDocGameController self
);

bool IsEquipmentAreaRequiringPerk(game.data.EquipmentArea equipmentArea) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "IsEquipmentAreaRequiringPerk;gamedataEquipmentArea",
    (RipperDocGameController_IsEquipmentAreaRequiringPerk x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_IsEquipmentAreaRequiringPerk(
    RipperDocGameController self,
    game.data.EquipmentArea equipmentArea
);

game.data.NewPerkType GetRequiredPerk(RipperdocHoverState hoverArea) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "GetRequiredPerk;RipperdocHoverState",
    (RipperDocGameController_GetRequiredPerk x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.NewPerkType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetRequiredPerk(
    RipperDocGameController self,
    RipperdocHoverState hoverArea
);

void SpawnPerks() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "SpawnPerks;",
    (RipperDocGameController_SpawnPerks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_SpawnPerks(
    RipperDocGameController self
);

void InitializeEquipmentMinigrids() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "InitializeEquipmentMinigrids;",
    (RipperDocGameController_InitializeEquipmentMinigrids x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_InitializeEquipmentMinigrids(
    RipperDocGameController self
);

bool OnSetScreenDisplayContext(IScriptable userData) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnSetScreenDisplayContext",
    (RipperDocGameController_OnSetScreenDisplayContext x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool OnBeforeLeaveScenario(IScriptable userData) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnBeforeLeaveScenario",
    (RipperDocGameController_OnBeforeLeaveScenario x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool OnCloseMenu(IScriptable userData) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnCloseMenu",
    (RipperDocGameController_OnCloseMenu x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool OnUninitialize() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnUninitialize(
    RipperDocGameController self
);

void Init() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "Init;",
    (RipperDocGameController_Init x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_Init(
    RipperDocGameController self
);

void RegisterBlackboard(game.Object player) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "RegisterBlackboard;GameObject",
    (RipperDocGameController_RegisterBlackboard x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_RegisterBlackboard(
    RipperDocGameController self,
    game.Object? player
);

void UnregisterBlackboard() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "UnregisterBlackboard;",
    (RipperDocGameController_UnregisterBlackboard x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_UnregisterBlackboard(
    RipperDocGameController self
);

void RegisterInventoryListener(game.Object player) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "RegisterInventoryListener;GameObject",
    (RipperDocGameController_RegisterInventoryListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_RegisterInventoryListener(
    RipperDocGameController self,
    game.Object? player
);

void UnregisterInventoryListener(game.Object player) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "UnregisterInventoryListener;GameObject",
    (RipperDocGameController_UnregisterInventoryListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_UnregisterInventoryListener(
    RipperDocGameController self,
    game.Object? player
);

void PopulateCategories() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "PopulateCategories;",
    (RipperDocGameController_PopulateCategories x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_PopulateCategories(
    RipperDocGameController self
);

void PreparePlayerItems() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "PreparePlayerItems;",
    (RipperDocGameController_PreparePlayerItems x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_PreparePlayerItems(
    RipperDocGameController self
);

void PrepareVendorItems() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "PrepareVendorItems;",
    (RipperDocGameController_PrepareVendorItems x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_PrepareVendorItems(
    RipperDocGameController self
);

void UpdateSoldItems() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "UpdateSoldItems;",
    (RipperDocGameController_UpdateSoldItems x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_UpdateSoldItems(
    RipperDocGameController self
);

void SpawnMinigrids() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "SpawnMinigrids;",
    (RipperDocGameController_SpawnMinigrids x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_SpawnMinigrids(
    RipperDocGameController self
);

void SpawnMinigrid(RipperdocCategory category) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "SpawnMinigrid;RipperdocCategory",
    (RipperDocGameController_SpawnMinigrid x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_SpawnMinigrid(
    RipperDocGameController self,
    RipperdocCategory category
);

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

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnMinigridSpawned",
    (RipperDocGameController_OnMinigridSpawned x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool DoesEquipAreaContainNewItems(game.data.EquipmentArea area) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "DoesEquipAreaContainNewItems;gamedataEquipmentArea",
    (RipperDocGameController_DoesEquipAreaContainNewItems x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_DoesEquipAreaContainNewItems(
    RipperDocGameController self,
    game.data.EquipmentArea area
);

bool EquipCyberware(WeakHandle<game.ItemData> itemData) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "EquipCyberware;gameItemData",
    (RipperDocGameController_EquipCyberware x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_EquipCyberware(
    RipperDocGameController self,
    WeakHandle<game.ItemData> itemData
);

bool OnUIEquipmentReplacedEvent(UIEquipmentReplacedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnUIEquipmentReplacedEvent",
    (RipperDocGameController_OnUIEquipmentReplacedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnUIEquipmentReplacedEvent(
    RipperDocGameController self,
    UIEquipmentReplacedEvent? evt
);

void PlayCyberwareSound(game.data.ItemType itemType, bool OnEquip, game.data.Quality itemQuality) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "PlayCyberwareSound;gamedataItemTypeBoolgamedataQuality",
    (RipperDocGameController_PlayCyberwareSound x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_PlayCyberwareSound(
    RipperDocGameController self,
    game.data.ItemType itemType,
    bool OnEquip,
    game.data.Quality itemQuality
);

bool CheckIfCanEquip(WeakHandle<game.ItemData> itemData, WeakHandle<game.ItemData> equipped) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "CheckIfCanEquip;gameItemDatagameItemData",
    (RipperDocGameController_CheckIfCanEquip x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_CheckIfCanEquip(
    RipperDocGameController self,
    WeakHandle<game.ItemData> itemData,
    WeakHandle<game.ItemData> equipped
);

bool CheckIfCanEquip(WeakHandle<game.ItemData> itemData, game.data.EquipmentArea itemArea) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "CheckIfCanEquip;gameItemDatagamedataEquipmentArea",
    (RipperDocGameController_CheckIfCanEquip2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_CheckIfCanEquip2(
    RipperDocGameController self,
    WeakHandle<game.ItemData> itemData,
    game.data.EquipmentArea itemArea
);

bool UnequipCyberware(WeakHandle<game.ItemData> itemData, bool? skipRefresh) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "UnequipCyberware;gameItemDataBool",
    (RipperDocGameController_UnequipCyberware x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_UnequipCyberware(
    RipperDocGameController self,
    WeakHandle<game.ItemData> itemData,
    bool? skipRefresh
);

void HandleItemEquippedNextFrame(game.ItemID itemID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "HandleItemEquippedNextFrame;ItemID",
    (RipperDocGameController_HandleItemEquippedNextFrame x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_HandleItemEquippedNextFrame(
    RipperDocGameController self,
    game.ItemID itemID
);

bool OnHandleItemEquippedNextFrameEvent(HandleItemEquippedNextFrameEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnHandleItemEquippedNextFrameEvent",
    (RipperDocGameController_OnHandleItemEquippedNextFrameEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnHandleItemEquippedNextFrameEvent(
    RipperDocGameController self,
    HandleItemEquippedNextFrameEvent? evt
);

void RequestHandleEquippedOnItemAdded(TDBID tweak) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "RequestHandleEquippedOnItemAdded;TweakDBID",
    (RipperDocGameController_RequestHandleEquippedOnItemAdded x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_RequestHandleEquippedOnItemAdded(
    RipperDocGameController self,
    TDBID tweak
);

void HandleItemEquipped(game.ItemID itemID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "HandleItemEquipped;ItemID",
    (RipperDocGameController_HandleItemEquipped x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_HandleItemEquipped(
    RipperDocGameController self,
    game.ItemID itemID
);

void InvalidateMinigridsNextFrame() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "InvalidateMinigridsNextFrame;",
    (RipperDocGameController_InvalidateMinigridsNextFrame x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_InvalidateMinigridsNextFrame(
    RipperDocGameController self
);

bool OnInvalidateMinigridsEvent(RipperdocInvalidateMinigridsNextFrame evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnInvalidateMinigridsEvent",
    (RipperDocGameController_OnInvalidateMinigridsEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnInvalidateMinigridsEvent(
    RipperDocGameController self,
    RipperdocInvalidateMinigridsNextFrame? evt
);

bool OnUIInventoryItemAdded(UIInventoryItemAdded evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnUIInventoryItemAdded",
    (RipperDocGameController_OnUIInventoryItemAdded x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnUIInventoryItemAdded(
    RipperDocGameController self,
    UIInventoryItemAdded? evt
);

bool OnUIInventoryItemRemoved(UIInventoryItemRemoved evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnUIInventoryItemRemoved",
    (RipperDocGameController_OnUIInventoryItemRemoved x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnUIInventoryItemRemoved(
    RipperDocGameController self,
    UIInventoryItemRemoved? evt
);

float GetMaxCapacityPossible() RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "GetMaxCapacityPossible;",
    (RipperDocGameController_GetMaxCapacityPossible x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetMaxCapacityPossible(
    RipperDocGameController self
);

void UpdateCapacityBar(bool isPurchase) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "UpdateCapacityBar;Bool",
    (RipperDocGameController_UpdateCapacityBar x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_UpdateCapacityBar(
    RipperDocGameController self,
    bool isPurchase
);

void UpdateArmorBar(bool isPurchase) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "UpdateArmorBar;Bool",
    (RipperDocGameController_UpdateArmorBar x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_UpdateArmorBar(
    RipperDocGameController self,
    bool isPurchase
);

bool OnIntroAnimationFinished_CAPACTIY_METER(ink.anim.Proxy proxy) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnIntroAnimationFinished_CAPACTIY_METER",
    (RipperDocGameController_OnIntroAnimationFinished_CAPACTIY_METER x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnIntroAnimationFinished_CAPACTIY_METER(
    RipperDocGameController self,
    ink.anim.Proxy? proxy
);

bool OnIntroAnimationFinished_ARMOR_METER(ink.anim.Proxy proxy) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnIntroAnimationFinished_ARMOR_METER",
    (RipperDocGameController_OnIntroAnimationFinished_ARMOR_METER x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnIntroAnimationFinished_ARMOR_METER(
    RipperDocGameController self,
    ink.anim.Proxy? proxy
);

bool OnArmorBarFinalizedEvent(ArmorBarFinalizedEvent e) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnArmorBarFinalizedEvent",
    (RipperDocGameController_OnArmorBarFinalizedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnArmorBarFinalizedEvent(
    RipperDocGameController self,
    ArmorBarFinalizedEvent? e
);

bool OnCapacityBarFinalizedEvent(CapacityBarFinalizedEvent e) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnCapacityBarFinalizedEvent",
    (RipperDocGameController_OnCapacityBarFinalizedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnCapacityBarFinalizedEvent(
    RipperDocGameController self,
    CapacityBarFinalizedEvent? e
);

bool OnPreviewCyberwareClick(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnPreviewCyberwareClick",
    (RipperDocGameController_OnPreviewCyberwareClick x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool OnEquipmentSlotClick(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnEquipmentSlotClick",
    (RipperDocGameController_OnEquipmentSlotClick x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

InventoryItemDisplayController? GetCyberwareSlotControllerFromTarget(ink.PointerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "GetCyberwareSlotControllerFromTarget;inkPointerEvent",
    (RipperDocGameController_GetCyberwareSlotControllerFromTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.InventoryItemDisplayController>();
    }
);

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

bool OnSlotClick(ItemDisplayClickEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnSlotClick",
    (RipperDocGameController_OnSlotClick x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnSlotClick(
    RipperDocGameController self,
    ItemDisplayClickEvent? evt
);

bool OnSlotHover(ItemDisplayHoverOverEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnSlotHover",
    (RipperDocGameController_OnSlotHover x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnSlotHover(
    RipperDocGameController self,
    ItemDisplayHoverOverEvent? evt
);

void RequestItemInspected(game.ItemID itemID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "RequestItemInspected;ItemID",
    (RipperDocGameController_RequestItemInspected x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_RequestItemInspected(
    RipperDocGameController self,
    game.ItemID itemID
);

bool OnSlotUnhover(ItemDisplayHoverOutEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnSlotUnhover",
    (RipperDocGameController_OnSlotUnhover x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnSlotUnhover(
    RipperDocGameController self,
    ItemDisplayHoverOutEvent? evt
);

bool OnBarHover(BarHoverOverEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnBarHover",
    (RipperDocGameController_OnBarHover x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnBarHover(
    RipperDocGameController self,
    BarHoverOverEvent? evt
);

bool OnBarUnhover(BarHoverOutEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnBarUnhover",
    (RipperDocGameController_OnBarUnhover x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnBarUnhover(
    RipperDocGameController self,
    BarHoverOutEvent? evt
);

RipperdocMeterCapacityHoverEvent? GetCapacityHoverEventData(WeakHandle<UIInventoryItem> item) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "GetCapacityHoverEventData;UIInventoryItem",
    (RipperDocGameController_GetCapacityHoverEventData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.RipperdocMeterCapacityHoverEvent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetCapacityHoverEventData(
    RipperDocGameController self,
    WeakHandle<UIInventoryItem> item
);

RipperdocMeterArmorHoverEvent? GetArmorHoverEventData(WeakHandle<UIInventoryItem> item) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "GetArmorHoverEventData;UIInventoryItem",
    (RipperDocGameController_GetArmorHoverEventData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.RipperdocMeterArmorHoverEvent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetArmorHoverEventData(
    RipperDocGameController self,
    WeakHandle<UIInventoryItem> item
);

InventoryTooltipData? GetTooltipData(WeakHandle<UIInventoryItem> item, WeakHandle<UIInventoryItem> equippedItem, bool isVendorItem, bool isBuybackStack)

RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "GetTooltipData;UIInventoryItemUIInventoryItemBoolBool",
    (RipperDocGameController_GetTooltipData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.InventoryTooltipData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetTooltipData(
    RipperDocGameController self,
    WeakHandle<UIInventoryItem> item,
    WeakHandle<UIInventoryItem> equippedItem,
    bool isVendorItem,
    bool isBuybackStack
);

InventoryTooltiData_CyberwareUpgradeData? GetCyberwareUpgradeData(WeakHandle<UIInventoryItem> item, bool? isUpgradeScreen)

RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "GetCyberwareUpgradeData;UIInventoryItemBool",
    (RipperDocGameController_GetCyberwareUpgradeData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.InventoryTooltiData_CyberwareUpgradeData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetCyberwareUpgradeData(
    RipperDocGameController self,
    WeakHandle<UIInventoryItem> item,
    bool? isUpgradeScreen
);

void HideOpposideSideCategoreis(bool isLeftSide) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "HideOpposideSideCategoreis;Bool",
    (RipperDocGameController_HideOpposideSideCategoreis x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_HideOpposideSideCategoreis(
    RipperDocGameController self,
    bool isLeftSide
);

void ShowCWTooltip(WeakHandle<UIInventoryItem> item, WeakHandle<UIInventoryItem> equippedItem, WeakHandle<ink.Widget> widget, bool isVendorItem, bool isBuyBack, DEBUG_IconErrorInfo? iconErrorInfo)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "ShowCWTooltip;UIInventoryItemUIInventoryIteminkWidgetBoolBoolDEBUG_IconErrorInfo",
    (RipperDocGameController_ShowCWTooltip x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_ShowCWTooltip(
    RipperDocGameController self,
    WeakHandle<UIInventoryItem> item,
    WeakHandle<UIInventoryItem> equippedItem,
    WeakHandle<ink.Widget> widget,
    bool isVendorItem,
    bool isBuyBack,
    DEBUG_IconErrorInfo? iconErrorInfo
);

void ShowCWPerkTooltip(WeakHandle<ink.Widget> widget) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "ShowCWPerkTooltip;inkWidget",
    (RipperDocGameController_ShowCWPerkTooltip x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_ShowCWPerkTooltip(
    RipperDocGameController self,
    WeakHandle<ink.Widget> widget
);

bool OnCategoryHoverOverEvent(CategoryHoverOverEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnCategoryHoverOverEvent",
    (RipperDocGameController_OnCategoryHoverOverEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnCategoryHoverOverEvent(
    RipperDocGameController self,
    CategoryHoverOverEvent? evt
);

bool OnCategoryHoverOutEvent(CategoryHoverOutEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnCategoryHoverOutEvent",
    (RipperDocGameController_OnCategoryHoverOutEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnCategoryHoverOutEvent(
    RipperDocGameController self,
    CategoryHoverOutEvent? evt
);

void ShowCategoryTooltip(game.data.EquipmentArea equipArea) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "ShowCategoryTooltip;gamedataEquipmentArea",
    (RipperDocGameController_ShowCategoryTooltip x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_ShowCategoryTooltip(
    RipperDocGameController self,
    game.data.EquipmentArea equipArea
);

void SetButtonHints(bool toDefault, bool? isClose) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "SetButtonHints;BoolBool",
    (RipperDocGameController_SetButtonHints x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_SetButtonHints(
    RipperDocGameController self,
    bool toDefault,
    bool? isClose
);

void SetButtonHintsHover(WeakHandle<UIInventoryItem> item, bool isVendorItem) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "SetButtonHintsHover;UIInventoryItemBool",
    (RipperDocGameController_SetButtonHintsHover x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_SetButtonHintsHover(
    RipperDocGameController self,
    WeakHandle<UIInventoryItem> item,
    bool isVendorItem
);

void SetButtonHintsUnhover() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "SetButtonHintsUnhover;",
    (RipperDocGameController_SetButtonHintsUnhover x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_SetButtonHintsUnhover(
    RipperDocGameController self
);

void RefreshInventoryNextFrame() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "RefreshInventoryNextFrame;",
    (RipperDocGameController_RefreshInventoryNextFrame x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_RefreshInventoryNextFrame(
    RipperDocGameController self
);

bool OnRefreshInventoryEvent(RipperdocRefreshInventoryEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnRefreshInventoryEvent",
    (RipperDocGameController_OnRefreshInventoryEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnRefreshInventoryEvent(
    RipperDocGameController self,
    RipperdocRefreshInventoryEvent? evt
);

void DisplayInventory(bool visible) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "DisplayInventory;Bool",
    (RipperDocGameController_DisplayInventory x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void AddTutorialItemsToStock(game.data.EquipmentArea area, bool? force) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "AddTutorialItemsToStock;gamedataEquipmentAreaBool",
    (RipperDocGameController_AddTutorialItemsToStock x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_AddTutorialItemsToStock(
    RipperDocGameController self,
    game.data.EquipmentArea area,
    bool? force
);

WeakHandle<WrappedUIInventoryItem>[] GetVendorItems(game.data.EquipmentArea area) RTTI

bool FilterItem(WeakHandle<UIInventoryItem> item) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "FilterItem;UIInventoryItem",
    (RipperDocGameController_FilterItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_FilterItem(
    RipperDocGameController self,
    WeakHandle<UIInventoryItem> item
);

RipperdocInventoryItemData? GetItemWrapper(game.InventoryItemData cachedInvyItem, bool isVendor, int playerCurrencyAmount)

RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "GetItemWrapper;InventoryItemDataBoolInt32",
    (RipperDocGameController_GetItemWrapper x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.RipperdocInventoryItemData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetItemWrapper(
    RipperDocGameController self,
    game.InventoryItemData cachedInvyItem,
    bool isVendor,
    int playerCurrencyAmount
);

float GetItemAttribute(WeakHandle<game.ItemData> itemData, game.data.StatType attribute) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "GetItemAttribute;gameItemDatagamedataStatType",
    (RipperDocGameController_GetItemAttribute x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetItemAttribute(
    RipperDocGameController self,
    WeakHandle<game.ItemData> itemData,
    game.data.StatType attribute
);

float GetItemAttribute(WeakHandle<UIInventoryItem> item, game.data.StatType attribute) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "GetItemAttribute;UIInventoryItemgamedataStatType",
    (RipperDocGameController_GetItemAttribute2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetItemAttribute2(
    RipperDocGameController self,
    WeakHandle<UIInventoryItem> item,
    game.data.StatType attribute
);

game.SItemStackRequirementData[] GetItemAttributes(WeakHandle<UIInventoryItem> item) RTTI

float GetItemArmor(WeakHandle<UIInventoryItem> item) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "GetItemArmor;UIInventoryItem",
    (RipperDocGameController_GetItemArmor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetItemArmor(
    RipperDocGameController self,
    WeakHandle<UIInventoryItem> item
);

void GetItemArmorBonuses(WeakHandle<UIInventoryItem> item, out float attunemend, out float multiplier) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "GetItemArmorBonuses;UIInventoryItemFloatFloat",
    (RipperDocGameController_GetItemArmorBonuses x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetItemArmorBonuses(
    RipperDocGameController self,
    WeakHandle<UIInventoryItem> item,
    float attunemend,
    float multiplier
);

bool OnSelectorChange(RipperdocSelectorChangeEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnSelectorChange",
    (RipperDocGameController_OnSelectorChange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnSelectorChange(
    RipperDocGameController self,
    RipperdocSelectorChangeEvent? evt
);

void ResetMinigridPositions() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "ResetMinigridPositions;",
    (RipperDocGameController_ResetMinigridPositions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_ResetMinigridPositions(
    RipperDocGameController self
);

void SetMinigridPosition(WeakHandle<CyberwareInventoryMiniGrid> target) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "SetMinigridPosition;CyberwareInventoryMiniGrid",
    (RipperDocGameController_SetMinigridPosition x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_SetMinigridPosition(
    RipperDocGameController self,
    WeakHandle<CyberwareInventoryMiniGrid> target
);

void AnimateMinigrids() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "AnimateMinigrids;",
    (RipperDocGameController_AnimateMinigrids x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_AnimateMinigrids(
    RipperDocGameController self
);

void UpdateMinigrids() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "UpdateMinigrids;",
    (RipperDocGameController_UpdateMinigrids x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_UpdateMinigrids(
    RipperDocGameController self
);

WeakHandle<CyberwareInventoryMiniGrid> GetMinigrid(game.data.EquipmentArea area) RTTI

void PreviewMinigridSelection(WeakHandle<UIInventoryItem>? item) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "PreviewMinigridSelection;UIInventoryItem",
    (RipperDocGameController_PreviewMinigridSelection x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_PreviewMinigridSelection(
    RipperDocGameController self,
    WeakHandle<UIInventoryItem>? item
);

void SetMinigridSelection(WeakHandle<InventoryItemDisplayController> slot) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "SetMinigridSelection;InventoryItemDisplayController",
    (RipperDocGameController_SetMinigridSelection x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_SetMinigridSelection(
    RipperDocGameController self,
    WeakHandle<InventoryItemDisplayController> slot
);

void ClearMinigridSelection() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "ClearMinigridSelection;",
    (RipperDocGameController_ClearMinigridSelection x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_ClearMinigridSelection(
    RipperDocGameController self
);

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

Generated hook

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

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

bool OnBack(IScriptable userData) overrideRTTI

Generated hook

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

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

void DollHover(game.data.EquipmentArea area) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "DollHover;gamedataEquipmentArea",
    (RipperDocGameController_DollHover x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_DollHover(
    RipperDocGameController self,
    game.data.EquipmentArea area
);

void DollSelect(bool select) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "DollSelect;Bool",
    (RipperDocGameController_DollSelect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_DollSelect(
    RipperDocGameController self,
    bool select
);

void UpdateAllItemCounters(game.data.EquipmentArea equipArea) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "UpdateAllItemCounters;gamedataEquipmentArea",
    (RipperDocGameController_UpdateAllItemCounters x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_UpdateAllItemCounters(
    RipperDocGameController self,
    game.data.EquipmentArea equipArea
);

int EquipmentAreaToIndex(game.data.EquipmentArea equipArea) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "EquipmentAreaToIndex;gamedataEquipmentArea",
    (RipperDocGameController_EquipmentAreaToIndex x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_EquipmentAreaToIndex(
    RipperDocGameController self,
    game.data.EquipmentArea equipArea
);

game.data.EquipmentArea IndexToEquipmentArea(int index) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "IndexToEquipmentArea;Int32",
    (RipperDocGameController_IndexToEquipmentArea x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.EquipmentArea>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_IndexToEquipmentArea(
    RipperDocGameController self,
    int index
);

void UpdateCachedAvailableItemCounters(game.data.EquipmentArea equipArea, int newCount) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "UpdateCachedAvailableItemCounters;gamedataEquipmentAreaInt32",
    (RipperDocGameController_UpdateCachedAvailableItemCounters x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_UpdateCachedAvailableItemCounters(
    RipperDocGameController self,
    game.data.EquipmentArea equipArea,
    int newCount
);

int GetCachedAvailableItemCounters(game.data.EquipmentArea equipArea) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "GetCachedAvailableItemCounters;gamedataEquipmentArea",
    (RipperDocGameController_GetCachedAvailableItemCounters x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetCachedAvailableItemCounters(
    RipperDocGameController self,
    game.data.EquipmentArea equipArea
);

void UpdateCachedVendorItemCounters(game.data.EquipmentArea equipArea, int newCount) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "UpdateCachedVendorItemCounters;gamedataEquipmentAreaInt32",
    (RipperDocGameController_UpdateCachedVendorItemCounters x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_UpdateCachedVendorItemCounters(
    RipperDocGameController self,
    game.data.EquipmentArea equipArea,
    int newCount
);

int GetCachedVendorItemCounters(game.data.EquipmentArea equipArea) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "GetCachedVendorItemCounters;gamedataEquipmentArea",
    (RipperDocGameController_GetCachedVendorItemCounters x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetCachedVendorItemCounters(
    RipperDocGameController self,
    game.data.EquipmentArea equipArea
);

void UpdateCachedPlayerItemCounters(game.data.EquipmentArea equipArea, int newCount) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "UpdateCachedPlayerItemCounters;gamedataEquipmentAreaInt32",
    (RipperDocGameController_UpdateCachedPlayerItemCounters x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_UpdateCachedPlayerItemCounters(
    RipperDocGameController self,
    game.data.EquipmentArea equipArea,
    int newCount
);

int GetCachedPlayerItemCounters(game.data.EquipmentArea equipArea) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "GetCachedPlayerItemCounters;gamedataEquipmentArea",
    (RipperDocGameController_GetCachedPlayerItemCounters x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetCachedPlayerItemCounters(
    RipperDocGameController self,
    game.data.EquipmentArea equipArea
);

int GetAmountOfAvailableItems(game.data.EquipmentArea equipArea) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "GetAmountOfAvailableItems;gamedataEquipmentArea",
    (RipperDocGameController_GetAmountOfAvailableItems x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetAmountOfAvailableItems(
    RipperDocGameController self,
    game.data.EquipmentArea equipArea
);

int GetAreaVendorItemCount(game.data.EquipmentArea equipmentArea) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "GetAreaVendorItemCount;gamedataEquipmentArea",
    (RipperDocGameController_GetAreaVendorItemCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetAreaVendorItemCount(
    RipperDocGameController self,
    game.data.EquipmentArea equipmentArea
);

int GetAreaPlayerItemCount(game.data.EquipmentArea equipmentArea) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "GetAreaPlayerItemCount;gamedataEquipmentArea",
    (RipperDocGameController_GetAreaPlayerItemCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetAreaPlayerItemCount(
    RipperDocGameController self,
    game.data.EquipmentArea equipmentArea
);

void OpenConfirmationPopup(WeakHandle<UIInventoryItem> item, int price, VendorConfirmationPopupType type, CName listener)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "OpenConfirmationPopup;UIInventoryItemInt32VendorConfirmationPopupTypeCName",
    (RipperDocGameController_OpenConfirmationPopup x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OpenConfirmationPopup(
    RipperDocGameController self,
    WeakHandle<UIInventoryItem> item,
    int price,
    VendorConfirmationPopupType type,
    CName listener
);

bool OnBuyConfirmationPopupClosed(ink.GameNotificationData data) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnBuyConfirmationPopupClosed",
    (RipperDocGameController_OnBuyConfirmationPopupClosed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnBuyConfirmationPopupClosed(
    RipperDocGameController self,
    ink.GameNotificationData? data
);

bool OnSellConfirmationPopupClosed(ink.GameNotificationData data) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnSellConfirmationPopupClosed",
    (RipperDocGameController_OnSellConfirmationPopupClosed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnSellConfirmationPopupClosed(
    RipperDocGameController self,
    ink.GameNotificationData? data
);

bool OnBuyShardPopupClosed(ink.GameNotificationData data) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnBuyShardPopupClosed",
    (RipperDocGameController_OnBuyShardPopupClosed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnBuyShardPopupClosed(
    RipperDocGameController self,
    ink.GameNotificationData? data
);

bool OnVendorHubMenuChanged(VendorHubMenuChanged evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnVendorHubMenuChanged",
    (RipperDocGameController_OnVendorHubMenuChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnVendorHubMenuChanged(
    RipperDocGameController self,
    VendorHubMenuChanged? evt
);

void OnItemBought(game.ItemID itemID, WeakHandle<game.ItemData> itemData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "OnItemBought;ItemIDgameItemData",
    (RipperDocGameController_OnItemBought x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnItemBought(
    RipperDocGameController self,
    game.ItemID itemID,
    WeakHandle<game.ItemData> itemData
);

void RemoveCachedVendorItem(game.ItemID itemID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "RemoveCachedVendorItem;ItemID",
    (RipperDocGameController_RemoveCachedVendorItem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_RemoveCachedVendorItem(
    RipperDocGameController self,
    game.ItemID itemID
);

bool OnUIVendorItemSoldEvent(UIVendorItemsSoldEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnUIVendorItemSoldEvent",
    (RipperDocGameController_OnUIVendorItemSoldEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnUIVendorItemSoldEvent(
    RipperDocGameController self,
    UIVendorItemsSoldEvent? evt
);

bool OnUIVendorItemBoughtEvent(UIVendorItemsBoughtEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnUIVendorItemBoughtEvent",
    (RipperDocGameController_OnUIVendorItemBoughtEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnUIVendorItemBoughtEvent(
    RipperDocGameController self,
    UIVendorItemsBoughtEvent? evt
);

void ShowMainScreenTutorials() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "ShowMainScreenTutorials;",
    (RipperDocGameController_ShowMainScreenTutorials x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_ShowMainScreenTutorials(
    RipperDocGameController self
);

void HideMainScreenTutorials() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "HideMainScreenTutorials;",
    (RipperDocGameController_HideMainScreenTutorials x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_HideMainScreenTutorials(
    RipperDocGameController self
);

void ShowInventoryTutorial() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "ShowInventoryTutorial;",
    (RipperDocGameController_ShowInventoryTutorial x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_ShowInventoryTutorial(
    RipperDocGameController self
);

void HideInventoryTutorial() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "HideInventoryTutorial;",
    (RipperDocGameController_HideInventoryTutorial x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_HideInventoryTutorial(
    RipperDocGameController self
);

bool OnCapacityHoverTutorial(RipperdocMeterCapacityHoverEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnCapacityHoverTutorial",
    (RipperDocGameController_OnCapacityHoverTutorial x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnCapacityHoverTutorial(
    RipperDocGameController self,
    RipperdocMeterCapacityHoverEvent? evt
);

void HideCapacityTutorial() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "HideCapacityTutorial;",
    (RipperDocGameController_HideCapacityTutorial x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_HideCapacityTutorial(
    RipperDocGameController self
);

bool OnArmorHoverTutorial(RipperdocMeterArmorHoverEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "OnArmorHoverTutorial",
    (RipperDocGameController_OnArmorHoverTutorial x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_OnArmorHoverTutorial(
    RipperDocGameController self,
    RipperdocMeterArmorHoverEvent? evt
);

void HideArmorTutorial() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "HideArmorTutorial;",
    (RipperDocGameController_HideArmorTutorial x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_HideArmorTutorial(
    RipperDocGameController self
);

void EnableFocusTutorialModeHandsAndEye() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "EnableFocusTutorialModeHandsAndEye;",
    (RipperDocGameController_EnableFocusTutorialModeHandsAndEye x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_EnableFocusTutorialModeHandsAndEye(
    RipperDocGameController self
);

void EnableFocusTutorialModeArmor() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "EnableFocusTutorialModeArmor;",
    (RipperDocGameController_EnableFocusTutorialModeArmor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_EnableFocusTutorialModeArmor(
    RipperDocGameController self
);

void DisableFocusTutorialMode() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "RipperDocGameController",
    "DisableFocusTutorialMode;",
    (RipperDocGameController_DisableFocusTutorialMode x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_DisableFocusTutorialMode(
    RipperDocGameController self
);

static TDBID GetAppropriateArmorTutorialCyberware(game.data.Quality itemQuality) staticRTTI global

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "RipperDocGameController::GetAppropriateArmorTutorialCyberware;gamedataQuality",
    (RipperDocGameController_GetAppropriateArmorTutorialCyberware x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetAppropriateArmorTutorialCyberware(
    game.data.Quality itemQuality
);

static float GetItemAttribute(WeakHandle<game.ItemData> itemData, game.data.StatType attribute, game.Object player) staticRTTI global

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "RipperDocGameController::GetItemAttribute;gameItemDatagamedataStatTypeGameObject",
    (RipperDocGameController_GetItemAttribute3 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetItemAttribute3(
    WeakHandle<game.ItemData> itemData,
    game.data.StatType attribute,
    game.Object? player
);

static float GetTutorialItemCapacityRequirement(TDBID tweakDBID, game.Object player) staticRTTI global

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "RipperDocGameController::GetTutorialItemCapacityRequirement;TweakDBIDGameObject",
    (RipperDocGameController_GetTutorialItemCapacityRequirement x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetTutorialItemCapacityRequirement(
    TDBID tweakDBID,
    game.Object? player
);

static CName GetItemType(game.data.ItemType itemType) staticRTTI global

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "RipperDocGameController::GetItemType;gamedataItemType",
    (RipperDocGameController_GetItemType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetItemType(
    game.data.ItemType itemType
);

static float GetApproximateTutorialCapacity(game.Object player, game.data.Quality quality, bool hasSmartLink) staticRTTI global

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "RipperDocGameController::GetApproximateTutorialCapacity;GameObjectgamedataQualityBool",
    (RipperDocGameController_GetApproximateTutorialCapacity x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetApproximateTutorialCapacity(
    game.Object? player,
    game.data.Quality quality,
    bool hasSmartLink
);

static TDBID GetAppropriateEyesTutorialCyberware(game.data.Quality itemQuality) staticRTTI global

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "RipperDocGameController::GetAppropriateEyesTutorialCyberware;gamedataQuality",
    (RipperDocGameController_GetAppropriateEyesTutorialCyberware x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetAppropriateEyesTutorialCyberware(
    game.data.Quality itemQuality
);

static TDBID GetAppropriateHandsTutorialCyberware(game.data.Quality itemQuality, bool isSmartLink) staticRTTI global

Generated hook

re.Hooks.Place(
    "RipperDocGameController",
    "RipperDocGameController::GetAppropriateHandsTutorialCyberware;gamedataQualityBool",
    (RipperDocGameController_GetAppropriateHandsTutorialCyberware2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RipperDocGameController_GetAppropriateHandsTutorialCyberware2(
    game.data.Quality itemQuality,
    bool isSmartLink
);

static TDBID[] GetCommonCraftingMaterials() staticRTTI global