class

EquipmentSystem

1 property
115 functions

Extends game.IEquipmentSystem game.ScriptableSystem game.IScriptableSystem IScriptable ISerializable

Properties

Property	Type	Offset
`ownerData`	`EquipmentSystemPlayerData?[]`	`0x0`	scripted

Functions

string GetHairSuffix(game.ItemID itemId, WeakHandle<game.Object> owner, game.data.ItemsFactoryAppearanceSuffixBase_Record suffixRecord)

RTTI

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "GetHairSuffix;ItemIDGameObjectItemsFactoryAppearanceSuffixBase_Record",
    (EquipmentSystem_GetHairSuffix x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetHairSuffix(
    EquipmentSystem self,
    game.ItemID itemId,
    WeakHandle<game.Object> owner,
    game.data.ItemsFactoryAppearanceSuffixBase_Record? suffixRecord
);

void OnPlayerAttach(game.PlayerAttachRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnPlayerAttach;PlayerAttachRequest",
    (EquipmentSystem_OnPlayerAttach x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnPlayerAttach(
    EquipmentSystem self,
    game.PlayerAttachRequest? request
);

void OnPlayerDetach(game.PlayerDetachRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnPlayerDetach;PlayerDetachRequest",
    (EquipmentSystem_OnPlayerDetach x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnPlayerDetach(
    EquipmentSystem self,
    game.PlayerDetachRequest? request
);

EquipmentSystemPlayerData? GetPlayerData(game.Object owner) RTTI

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "GetPlayerData;GameObject",
    (EquipmentSystem_GetPlayerData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EquipmentSystemPlayerData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetPlayerData(
    EquipmentSystem self,
    game.Object? owner
);

void OnRestored(int saveVersion, int gameVersion) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnRestored;Int32Int32",
    (EquipmentSystem_OnRestored x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnRestored(
    EquipmentSystem self,
    int saveVersion,
    int gameVersion
);

void InitializeWardrobeDatabase() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "InitializeWardrobeDatabase;",
    (EquipmentSystem_InitializeWardrobeDatabase x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_InitializeWardrobeDatabase(
    EquipmentSystem self
);

void RefreshItemPlayerScaling() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "RefreshItemPlayerScaling;",
    (EquipmentSystem_RefreshItemPlayerScaling x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_RefreshItemPlayerScaling(
    EquipmentSystem self
);

void ProcessNonIconicWeaponsRescale() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "ProcessNonIconicWeaponsRescale;",
    (EquipmentSystem_ProcessNonIconicWeaponsRescale x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_ProcessNonIconicWeaponsRescale(
    EquipmentSystem self
);

void RestoreCybWeaponQualities() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "RestoreCybWeaponQualities;",
    (EquipmentSystem_RestoreCybWeaponQualities x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_RestoreCybWeaponQualities(
    EquipmentSystem self
);

void ConsumablesChargesRework() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "ConsumablesChargesRework;",
    (EquipmentSystem_ConsumablesChargesRework x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_ConsumablesChargesRework(
    EquipmentSystem self
);

void BlockAndCompensateScaling() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "BlockAndCompensateScaling;",
    (EquipmentSystem_BlockAndCompensateScaling x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_BlockAndCompensateScaling(
    EquipmentSystem self
);

void IconicsReworkCompensate() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "IconicsReworkCompensate;",
    (EquipmentSystem_IconicsReworkCompensate x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_IconicsReworkCompensate(
    EquipmentSystem self
);

void GiveFixerShirt() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "GiveFixerShirt;",
    (EquipmentSystem_GiveFixerShirt x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GiveFixerShirt(
    EquipmentSystem self
);

void GiveSaburoTanto() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "GiveSaburoTanto;",
    (EquipmentSystem_GiveSaburoTanto x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GiveSaburoTanto(
    EquipmentSystem self
);

void CheckSaburoDogTagPresence() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "CheckSaburoDogTagPresence;",
    (EquipmentSystem_CheckSaburoDogTagPresence x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_CheckSaburoDogTagPresence(
    EquipmentSystem self
);

void ProcessIconicsFactsForBlackMarketer() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "ProcessIconicsFactsForBlackMarketer;",
    (EquipmentSystem_ProcessIconicsFactsForBlackMarketer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_ProcessIconicsFactsForBlackMarketer(
    EquipmentSystem self
);

void GiveAndEquipAutoscalingFleshFists() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "GiveAndEquipAutoscalingFleshFists;",
    (EquipmentSystem_GiveAndEquipAutoscalingFleshFists x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GiveAndEquipAutoscalingFleshFists(
    EquipmentSystem self
);

void ReplaceLeftHandVariantWeaponsWithRegular() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "ReplaceLeftHandVariantWeaponsWithRegular;",
    (EquipmentSystem_ReplaceLeftHandVariantWeaponsWithRegular x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_ReplaceLeftHandVariantWeaponsWithRegular(
    EquipmentSystem self
);

void RetrofixQuickhacks() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "RetrofixQuickhacks;",
    (EquipmentSystem_RetrofixQuickhacks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_RetrofixQuickhacks(
    EquipmentSystem self
);

void RetrofixHolsteredArms() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "RetrofixHolsteredArms;",
    (EquipmentSystem_RetrofixHolsteredArms x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_RetrofixHolsteredArms(
    EquipmentSystem self
);

void RetrofixCyberwares() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "RetrofixCyberwares;",
    (EquipmentSystem_RetrofixCyberwares x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_RetrofixCyberwares(
    EquipmentSystem self
);

void RetrofixOverallocatedCyberware() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "RetrofixOverallocatedCyberware;",
    (EquipmentSystem_RetrofixOverallocatedCyberware x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_RetrofixOverallocatedCyberware(
    EquipmentSystem self
);

void CheckReginaRewardsPresence() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "CheckReginaRewardsPresence;",
    (EquipmentSystem_CheckReginaRewardsPresence x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_CheckReginaRewardsPresence(
    EquipmentSystem self
);

void RemoveDeprecatedReginaCWReward() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "RemoveDeprecatedReginaCWReward;",
    (EquipmentSystem_RemoveDeprecatedReginaCWReward x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_RemoveDeprecatedReginaCWReward(
    EquipmentSystem self
);

void RemoveNPCMeleeware() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "RemoveNPCMeleeware;",
    (EquipmentSystem_RemoveNPCMeleeware x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_RemoveNPCMeleeware(
    EquipmentSystem self
);

void ProcessMaskCWRestoration() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "ProcessMaskCWRestoration;",
    (EquipmentSystem_ProcessMaskCWRestoration x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_ProcessMaskCWRestoration(
    EquipmentSystem self
);

void ProcessQ105AccessCardFacts() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "ProcessQ105AccessCardFacts;",
    (EquipmentSystem_ProcessQ105AccessCardFacts x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_ProcessQ105AccessCardFacts(
    EquipmentSystem self
);

void IconicsUpgradeCountWithEffectiveTierMatch() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "IconicsUpgradeCountWithEffectiveTierMatch;",
    (EquipmentSystem_IconicsUpgradeCountWithEffectiveTierMatch x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_IconicsUpgradeCountWithEffectiveTierMatch(
    EquipmentSystem self
);

void RasetsuItemPlayerScaling() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "RasetsuItemPlayerScaling;",
    (EquipmentSystem_RasetsuItemPlayerScaling x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_RasetsuItemPlayerScaling(
    EquipmentSystem self
);

void PrintEquipment() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "PrintEquipment;",
    (EquipmentSystem_PrintEquipment x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_PrintEquipment(
    EquipmentSystem self
);

game.ItemID GetItemInEquipSlot(game.Object owner, game.data.EquipmentArea equipArea, int slotIndex) RTTI

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "GetItemInEquipSlot;GameObjectgamedataEquipmentAreaInt32",
    (EquipmentSystem_GetItemInEquipSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetItemInEquipSlot(
    EquipmentSystem self,
    game.Object? owner,
    game.data.EquipmentArea equipArea,
    int slotIndex
);

bool IsEquipped(game.Object owner, game.ItemID item) RTTI

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "IsEquipped;GameObjectItemID",
    (EquipmentSystem_IsEquipped x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_IsEquipped(
    EquipmentSystem self,
    game.Object? owner,
    game.ItemID item
);

bool IsEquippable(game.Object owner, WeakHandle<game.ItemData> itemData) RTTI

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "IsEquippable;GameObjectgameItemData",
    (EquipmentSystem_IsEquippable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_IsEquippable(
    EquipmentSystem self,
    game.Object? owner,
    WeakHandle<game.ItemData> itemData
);

bool IsEquipped(game.Object owner, game.ItemID item, game.data.EquipmentArea equipmentArea) RTTI

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "IsEquipped;GameObjectItemIDgamedataEquipmentArea",
    (EquipmentSystem_IsEquipped2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_IsEquipped2(
    EquipmentSystem self,
    game.Object? owner,
    game.ItemID item,
    game.data.EquipmentArea equipmentArea
);

game.ItemID GetActiveItem(game.Object owner, game.data.EquipmentArea area) RTTI

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "GetActiveItem;GameObjectgamedataEquipmentArea",
    (EquipmentSystem_GetActiveItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetActiveItem(
    EquipmentSystem self,
    game.Object? owner,
    game.data.EquipmentArea area
);

game.ItemID GetActiveVisualItem(game.Object owner, game.data.EquipmentArea area) RTTI

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "GetActiveVisualItem;GameObjectgamedataEquipmentArea",
    (EquipmentSystem_GetActiveVisualItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetActiveVisualItem(
    EquipmentSystem self,
    game.Object? owner,
    game.data.EquipmentArea area
);

game.data.EquipmentArea[] GetPaperDollSlots(game.Object owner) RTTI

game.ItemObject? GetActiveWeaponObject(game.Object owner, game.data.EquipmentArea area) RTTI

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "GetActiveWeaponObject;GameObjectgamedataEquipmentArea",
    (EquipmentSystem_GetActiveWeaponObject x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetActiveWeaponObject(
    EquipmentSystem self,
    game.Object? owner,
    game.data.EquipmentArea area
);

game.SEquipSlot[] GetAllInstalledCyberwareAbilities(game.Object owner) RTTI

int GetItemSlotIndex(game.Object owner, game.ItemID item) RTTI

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "GetItemSlotIndex;GameObjectItemID",
    (EquipmentSystem_GetItemSlotIndex x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetItemSlotIndex(
    EquipmentSystem self,
    game.Object? owner,
    game.ItemID item
);

bool IsItemInHotkey(WeakHandle<game.Object> owner, game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "IsItemInHotkey;GameObjectItemID",
    (EquipmentSystem_IsItemInHotkey x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_IsItemInHotkey(
    EquipmentSystem self,
    WeakHandle<game.Object> owner,
    game.ItemID itemID
);

game.EHotkey GetHotkeyTypeForItemID(WeakHandle<game.Object> owner, game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "GetHotkeyTypeForItemID;GameObjectItemID",
    (EquipmentSystem_GetHotkeyTypeForItemID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.EHotkey>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetHotkeyTypeForItemID(
    EquipmentSystem self,
    WeakHandle<game.Object> owner,
    game.ItemID itemID
);

game.EHotkey GetHotkeyTypeFromItemID(WeakHandle<game.Object> owner, game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "GetHotkeyTypeFromItemID;GameObjectItemID",
    (EquipmentSystem_GetHotkeyTypeFromItemID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.EHotkey>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetHotkeyTypeFromItemID(
    EquipmentSystem self,
    WeakHandle<game.Object> owner,
    game.ItemID itemID
);

game.ItemID GetItemIDFromHotkey(WeakHandle<game.Object> owner, game.EHotkey hotkey) RTTI

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "GetItemIDFromHotkey;GameObjectEHotkey",
    (EquipmentSystem_GetItemIDFromHotkey x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetItemIDFromHotkey(
    EquipmentSystem self,
    WeakHandle<game.Object> owner,
    game.EHotkey hotkey
);

game.SEquipArea GetEquipAreaFromItemID(game.Object owner, game.ItemID item) RTTI

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "GetEquipAreaFromItemID;GameObjectItemID",
    (EquipmentSystem_GetEquipAreaFromItemID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.SEquipArea>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetEquipAreaFromItemID(
    EquipmentSystem self,
    game.Object? owner,
    game.ItemID item
);

void OnEquipRequest(game.EquipRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnEquipRequest;EquipRequest",
    (EquipmentSystem_OnEquipRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnEquipRequest(
    EquipmentSystem self,
    game.EquipRequest? request
);

void OnGameplayEquipRequest(GameplayEquipRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnGameplayEquipRequest;GameplayEquipRequest",
    (EquipmentSystem_OnGameplayEquipRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnGameplayEquipRequest(
    EquipmentSystem self,
    GameplayEquipRequest? request
);

void OnGameplayEquipProgramsRequest(GameplayEquipProgramsRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnGameplayEquipProgramsRequest;GameplayEquipProgramsRequest",
    (EquipmentSystem_OnGameplayEquipProgramsRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnGameplayEquipProgramsRequest(
    EquipmentSystem self,
    GameplayEquipProgramsRequest? request
);

void OnClearAllWeaponSlotsRequest(ClearAllWeaponSlotsRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnClearAllWeaponSlotsRequest;ClearAllWeaponSlotsRequest",
    (EquipmentSystem_OnClearAllWeaponSlotsRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnClearAllWeaponSlotsRequest(
    EquipmentSystem self,
    ClearAllWeaponSlotsRequest? request
);

void OnEquipVisualsRequest(EquipVisualsRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnEquipVisualsRequest;EquipVisualsRequest",
    (EquipmentSystem_OnEquipVisualsRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnEquipVisualsRequest(
    EquipmentSystem self,
    EquipVisualsRequest? request
);

void OnUnequipVisualsRequest(UnequipVisualsRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnUnequipVisualsRequest;UnequipVisualsRequest",
    (EquipmentSystem_OnUnequipVisualsRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnUnequipVisualsRequest(
    EquipmentSystem self,
    UnequipVisualsRequest? request
);

void OnUnequipRequest(UnequipRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnUnequipRequest;UnequipRequest",
    (EquipmentSystem_OnUnequipRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnUnequipRequest(
    EquipmentSystem self,
    UnequipRequest? request
);

void OnUnequipItemsRequest(UnequipItemsRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnUnequipItemsRequest;UnequipItemsRequest",
    (EquipmentSystem_OnUnequipItemsRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnUnequipItemsRequest(
    EquipmentSystem self,
    UnequipItemsRequest? request
);

void OnReplaceEquipmentRequest(ReplaceEquipmentRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnReplaceEquipmentRequest;ReplaceEquipmentRequest",
    (EquipmentSystem_OnReplaceEquipmentRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnReplaceEquipmentRequest(
    EquipmentSystem self,
    ReplaceEquipmentRequest? request
);

void OnHotkeyRefreshRequest(HotkeyRefreshRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnHotkeyRefreshRequest;HotkeyRefreshRequest",
    (EquipmentSystem_OnHotkeyRefreshRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnHotkeyRefreshRequest(
    EquipmentSystem self,
    HotkeyRefreshRequest? request
);

void OnHotkeyAssignmentRequest(HotkeyAssignmentRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnHotkeyAssignmentRequest;HotkeyAssignmentRequest",
    (EquipmentSystem_OnHotkeyAssignmentRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnHotkeyAssignmentRequest(
    EquipmentSystem self,
    HotkeyAssignmentRequest? request
);

void OnAssignHotkeyIfEmptySlot(AssignHotkeyIfEmptySlot request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnAssignHotkeyIfEmptySlot;AssignHotkeyIfEmptySlot",
    (EquipmentSystem_OnAssignHotkeyIfEmptySlot x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnAssignHotkeyIfEmptySlot(
    EquipmentSystem self,
    AssignHotkeyIfEmptySlot? request
);

void OnInstallCyberwareRequest(InstallCyberwareRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnInstallCyberwareRequest;InstallCyberwareRequest",
    (EquipmentSystem_OnInstallCyberwareRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnInstallCyberwareRequest(
    EquipmentSystem self,
    InstallCyberwareRequest? request
);

void OnUninstallCyberwareRequest(UninstallCyberwareRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnUninstallCyberwareRequest;UninstallCyberwareRequest",
    (EquipmentSystem_OnUninstallCyberwareRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnUninstallCyberwareRequest(
    EquipmentSystem self,
    UninstallCyberwareRequest? request
);

void OnDrawItemRequest(game.DrawItemRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnDrawItemRequest;DrawItemRequest",
    (EquipmentSystem_OnDrawItemRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnDrawItemRequest(
    EquipmentSystem self,
    game.DrawItemRequest? request
);

void OnPartInstallRequest(PartInstallRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnPartInstallRequest;PartInstallRequest",
    (EquipmentSystem_OnPartInstallRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnPartInstallRequest(
    EquipmentSystem self,
    PartInstallRequest? request
);

void OnPartUninstallRequest(PartUninstallRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnPartUninstallRequest;PartUninstallRequest",
    (EquipmentSystem_OnPartUninstallRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnPartUninstallRequest(
    EquipmentSystem self,
    PartUninstallRequest? request
);

void OnClearEquipmentRequest(ClearEquipmentRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnClearEquipmentRequest;ClearEquipmentRequest",
    (EquipmentSystem_OnClearEquipmentRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnClearEquipmentRequest(
    EquipmentSystem self,
    ClearEquipmentRequest? request
);

void OnSaveEquipmentSetRequest(SaveEquipmentSetRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnSaveEquipmentSetRequest;SaveEquipmentSetRequest",
    (EquipmentSystem_OnSaveEquipmentSetRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnSaveEquipmentSetRequest(
    EquipmentSystem self,
    SaveEquipmentSetRequest? request
);

void OnLoadEquipmentSetRequest(LoadEquipmentSetRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnLoadEquipmentSetRequest;LoadEquipmentSetRequest",
    (EquipmentSystem_OnLoadEquipmentSetRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnLoadEquipmentSetRequest(
    EquipmentSystem self,
    LoadEquipmentSetRequest? request
);

void OnDeleteEquipmentSetRequest(DeleteEquipmentSetRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnDeleteEquipmentSetRequest;DeleteEquipmentSetRequest",
    (EquipmentSystem_OnDeleteEquipmentSetRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnDeleteEquipmentSetRequest(
    EquipmentSystem self,
    DeleteEquipmentSetRequest? request
);

void OnAssignToCyberwareWheelRequest(AssignToCyberwareWheelRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnAssignToCyberwareWheelRequest;AssignToCyberwareWheelRequest",
    (EquipmentSystem_OnAssignToCyberwareWheelRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnAssignToCyberwareWheelRequest(
    EquipmentSystem self,
    AssignToCyberwareWheelRequest? request
);

void OnEquipmentUIBBRequest(EquipmentUIBBRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnEquipmentUIBBRequest;EquipmentUIBBRequest",
    (EquipmentSystem_OnEquipmentUIBBRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnEquipmentUIBBRequest(
    EquipmentSystem self,
    EquipmentUIBBRequest? request
);

void OnCheckRemovedItemWithSlotActiveItem(CheckRemovedItemWithSlotActiveItem request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnCheckRemovedItemWithSlotActiveItem;CheckRemovedItemWithSlotActiveItem",
    (EquipmentSystem_OnCheckRemovedItemWithSlotActiveItem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnCheckRemovedItemWithSlotActiveItem(
    EquipmentSystem self,
    CheckRemovedItemWithSlotActiveItem? request
);

void OnSynchronizeAttachmentSlotRequest(game.SynchronizeAttachmentSlotRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnSynchronizeAttachmentSlotRequest;SynchronizeAttachmentSlotRequest",
    (EquipmentSystem_OnSynchronizeAttachmentSlotRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnSynchronizeAttachmentSlotRequest(
    EquipmentSystem self,
    game.SynchronizeAttachmentSlotRequest? request
);

void OnEquipWardrobeSetRequest(EquipWardrobeSetRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnEquipWardrobeSetRequest;EquipWardrobeSetRequest",
    (EquipmentSystem_OnEquipWardrobeSetRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnEquipWardrobeSetRequest(
    EquipmentSystem self,
    EquipWardrobeSetRequest? request
);

void OnUnequipWardrobeSetRequest(UnequipWardrobeSetRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnUnequipWardrobeSetRequest;UnequipWardrobeSetRequest",
    (EquipmentSystem_OnUnequipWardrobeSetRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnUnequipWardrobeSetRequest(
    EquipmentSystem self,
    UnequipWardrobeSetRequest? request
);

void OnDeleteWardrobeSetRequest(DeleteWardrobeSetRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnDeleteWardrobeSetRequest;DeleteWardrobeSetRequest",
    (EquipmentSystem_OnDeleteWardrobeSetRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnDeleteWardrobeSetRequest(
    EquipmentSystem self,
    DeleteWardrobeSetRequest? request
);

void OnQuestRestoreWardrobeSetRequest(QuestRestoreWardrobeSetRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnQuestRestoreWardrobeSetRequest;QuestRestoreWardrobeSetRequest",
    (EquipmentSystem_OnQuestRestoreWardrobeSetRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnQuestRestoreWardrobeSetRequest(
    EquipmentSystem self,
    QuestRestoreWardrobeSetRequest? request
);

void OnQuestDisableWardrobeSetRequest(QuestDisableWardrobeSetRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnQuestDisableWardrobeSetRequest;QuestDisableWardrobeSetRequest",
    (EquipmentSystem_OnQuestDisableWardrobeSetRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnQuestDisableWardrobeSetRequest(
    EquipmentSystem self,
    QuestDisableWardrobeSetRequest? request
);

void OnQuestEnableWardrobeSetRequest(QuestEnableWardrobeSetRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnQuestEnableWardrobeSetRequest;QuestEnableWardrobeSetRequest",
    (EquipmentSystem_OnQuestEnableWardrobeSetRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnQuestEnableWardrobeSetRequest(
    EquipmentSystem self,
    QuestEnableWardrobeSetRequest? request
);

void OnQuestHideSlotRequest(QuestHideSlotRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnQuestHideSlotRequest;QuestHideSlotRequest",
    (EquipmentSystem_OnQuestHideSlotRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnQuestHideSlotRequest(
    EquipmentSystem self,
    QuestHideSlotRequest? request
);

void OnQuestRestoreSlotRequest(QuestRestoreSlotRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnQuestRestoreSlotRequest;QuestRestoreSlotRequest",
    (EquipmentSystem_OnQuestRestoreSlotRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnQuestRestoreSlotRequest(
    EquipmentSystem self,
    QuestRestoreSlotRequest? request
);

void EquipCyberwareByTDBID(PlayerPuppet player, TDBID tdbid) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "EquipCyberwareByTDBID;PlayerPuppetTweakDBID",
    (EquipmentSystem_EquipCyberwareByTDBID x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_EquipCyberwareByTDBID(
    EquipmentSystem self,
    PlayerPuppet? player,
    TDBID tdbid
);

void EquipTutorialCyberware(PlayerPuppet player) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "EquipTutorialCyberware;PlayerPuppet",
    (EquipmentSystem_EquipTutorialCyberware x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_EquipTutorialCyberware(
    EquipmentSystem self,
    PlayerPuppet? player
);

void OnDrawItemByContextRequest(game.DrawItemByContextRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnDrawItemByContextRequest;DrawItemByContextRequest",
    (EquipmentSystem_OnDrawItemByContextRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnDrawItemByContextRequest(
    EquipmentSystem self,
    game.DrawItemByContextRequest? request
);

void OnUnequipByTDBIDRequest(game.UnequipByTDBIDRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnUnequipByTDBIDRequest;UnequipByTDBIDRequest",
    (EquipmentSystem_OnUnequipByTDBIDRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnUnequipByTDBIDRequest(
    EquipmentSystem self,
    game.UnequipByTDBIDRequest? request
);

void OnUnequipByContextRequest(game.UnequipByContextRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnUnequipByContextRequest;UnequipByContextRequest",
    (EquipmentSystem_OnUnequipByContextRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnUnequipByContextRequest(
    EquipmentSystem self,
    game.UnequipByContextRequest? request
);

void Debug_SetupEquipmentSystemOverlay(WeakHandle<game.Object> dataOwner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "Debug_SetupEquipmentSystemOverlay;GameObject",
    (EquipmentSystem_Debug_SetupEquipmentSystemOverlay x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_Debug_SetupEquipmentSystemOverlay(
    EquipmentSystem self,
    WeakHandle<game.Object> dataOwner
);

void Debug_SetupESAreaButton(game.SEquipArea equipArea, WeakHandle<game.Object> ownerGameObject) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "Debug_SetupESAreaButton;script_ref<SEquipArea>GameObject",
    (EquipmentSystem_Debug_SetupESAreaButton x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_Debug_SetupESAreaButton(
    EquipmentSystem self,
    game.SEquipArea equipArea,
    WeakHandle<game.Object> ownerGameObject
);

void Debug_SetupESSlotButton(int slotIndex, string areaStr, WeakHandle<game.Object> ownerGameObject) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "Debug_SetupESSlotButton;Int32script_ref<String>GameObject",
    (EquipmentSystem_Debug_SetupESSlotButton x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_Debug_SetupESSlotButton(
    EquipmentSystem self,
    int slotIndex,
    string areaStr,
    WeakHandle<game.Object> ownerGameObject
);

void Debug_SetESSlotData(int slotIndex, string areaStr, WeakHandle<game.Object> ownerGameObject) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "Debug_SetESSlotData;Int32script_ref<String>GameObject",
    (EquipmentSystem_Debug_SetESSlotData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_Debug_SetESSlotData(
    EquipmentSystem self,
    int slotIndex,
    string areaStr,
    WeakHandle<game.Object> ownerGameObject
);

void Debug_FillESSlotData(int slotIndex, game.data.EquipmentArea area, game.ItemID itemID, WeakHandle<game.Object> ownerGameObject)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "Debug_FillESSlotData;Int32gamedataEquipmentAreaItemIDGameObject",
    (EquipmentSystem_Debug_FillESSlotData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_Debug_FillESSlotData(
    EquipmentSystem self,
    int slotIndex,
    game.data.EquipmentArea area,
    game.ItemID itemID,
    WeakHandle<game.Object> ownerGameObject
);

void Debug_FillESSlotData(int slotIndex, string areaStr, game.ItemID itemID, WeakHandle<game.Object> ownerGameObject) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "Debug_FillESSlotData;Int32script_ref<String>ItemIDGameObject",
    (EquipmentSystem_Debug_FillESSlotData2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_Debug_FillESSlotData2(
    EquipmentSystem self,
    int slotIndex,
    string areaStr,
    game.ItemID itemID,
    WeakHandle<game.Object> ownerGameObject
);

void OnEquipmentSystemWeaponManipulationRequest(EquipmentSystemWeaponManipulationRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnEquipmentSystemWeaponManipulationRequest;EquipmentSystemWeaponManipulationRequest",
    (EquipmentSystem_OnEquipmentSystemWeaponManipulationRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnEquipmentSystemWeaponManipulationRequest(
    EquipmentSystem self,
    EquipmentSystemWeaponManipulationRequest? request
);

void OnSetActiveItemInEquipmentArea(SetActiveItemInEquipmentArea request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "OnSetActiveItemInEquipmentArea;SetActiveItemInEquipmentArea",
    (EquipmentSystem_OnSetActiveItemInEquipmentArea x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_OnSetActiveItemInEquipmentArea(
    EquipmentSystem self,
    SetActiveItemInEquipmentArea? request
);

WeakHandle<InventoryDataManagerV2> GetInventoryManager(WeakHandle<game.Object> owner) RTTI

static bool HasItemInArea(game.Object owner, game.data.EquipmentArea area) staticRTTI global

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "EquipmentSystem::HasItemInArea;GameObjectgamedataEquipmentArea",
    (EquipmentSystem_HasItemInArea x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_HasItemInArea(
    game.Object? owner,
    game.data.EquipmentArea area
);

static bool IsClothing(game.ItemID item) staticRTTI global

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "EquipmentSystem::IsClothing;ItemID",
    (EquipmentSystem_IsClothing x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_IsClothing(
    game.ItemID item
);

static TDBID GetPlacementSlot(game.ItemID item) staticRTTI global

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "EquipmentSystem::GetPlacementSlot;ItemID",
    (EquipmentSystem_GetPlacementSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetPlacementSlot(
    game.ItemID item
);

static bool IsCyberdeckEquipped(game.Object owner) staticRTTI global

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "EquipmentSystem::IsCyberdeckEquipped;GameObject",
    (EquipmentSystem_IsCyberdeckEquipped x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_IsCyberdeckEquipped(
    game.Object? owner
);

static game.data.EquipmentArea GetEquipAreaTypeForDpad(game.ItemID item) staticRTTI global

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "EquipmentSystem::GetEquipAreaTypeForDpad;ItemID",
    (EquipmentSystem_GetEquipAreaTypeForDpad x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.EquipmentArea>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetEquipAreaTypeForDpad(
    game.ItemID item
);

static EquipmentSystem? GetInstance(game.Object owner) staticRTTI global

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "EquipmentSystem::GetInstance;GameObject",
    (EquipmentSystem_GetInstance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EquipmentSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetInstance(
    game.Object? owner
);

static game.ItemID GetSlotActiveItem(game.Object owner, EquipmentManipulationRequestSlot requestSlot) staticRTTI global

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "EquipmentSystem::GetSlotActiveItem;GameObjectEquipmentManipulationRequestSlot",
    (EquipmentSystem_GetSlotActiveItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetSlotActiveItem(
    game.Object? owner,
    EquipmentManipulationRequestSlot requestSlot
);

static string ComposeSDORootPath(WeakHandle<game.Object> ownerGameObject, string suffix) staticRTTI global

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "EquipmentSystem::ComposeSDORootPath;GameObjectString",
    (EquipmentSystem_ComposeSDORootPath x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_ComposeSDORootPath(
    WeakHandle<game.Object> ownerGameObject,
    string suffix
);

static CName GetClothingItemAppearanceName(game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "EquipmentSystem::GetClothingItemAppearanceName;ItemID",
    (EquipmentSystem_GetClothingItemAppearanceName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetClothingItemAppearanceName(
    game.ItemID itemID
);

static game.ItemID GetFirstAvailableWeapon(game.Object owner) staticRTTI global

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "EquipmentSystem::GetFirstAvailableWeapon;GameObject",
    (EquipmentSystem_GetFirstAvailableWeapon x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetFirstAvailableWeapon(
    game.Object? owner
);

static bool IsItemCyberdeck(game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "EquipmentSystem::IsItemCyberdeck;ItemID",
    (EquipmentSystem_IsItemCyberdeck x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_IsItemCyberdeck(
    game.ItemID itemID
);

static game.ItemID GetLastUsedItemByType(game.Object owner, ELastUsed type) staticRTTI global

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "EquipmentSystem::GetLastUsedItemByType;GameObjectELastUsed",
    (EquipmentSystem_GetLastUsedItemByType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetLastUsedItemByType(
    game.Object? owner,
    ELastUsed type
);

static bool IsItemOfCategory(game.ItemID item, game.data.ItemCategory category) staticRTTI global

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "EquipmentSystem::IsItemOfCategory;ItemIDgamedataItemCategory",
    (EquipmentSystem_IsItemOfCategory x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_IsItemOfCategory(
    game.ItemID item,
    game.data.ItemCategory category
);

static game.ClothingSet? GetActiveWardrobeSet(game.Object owner) staticRTTI global

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "EquipmentSystem::GetActiveWardrobeSet;GameObject",
    (EquipmentSystem_GetActiveWardrobeSet x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ClothingSet>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetActiveWardrobeSet(
    game.Object? owner
);

static void UnequipPrereqItems(game.Object owner) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "EquipmentSystem::UnequipPrereqItems;GameObject",
    (EquipmentSystem_UnequipPrereqItems x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_UnequipPrereqItems(
    game.Object? owner
);

static game.ItemID[] GetItemsInArea(game.Object owner, game.data.EquipmentArea area) staticRTTI global

static game.WardrobeClothingSetIndex GetActiveWardrobeSetID(game.Object owner) staticRTTI global

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "EquipmentSystem::GetActiveWardrobeSetID;GameObject",
    (EquipmentSystem_GetActiveWardrobeSetID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.WardrobeClothingSetIndex>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetActiveWardrobeSetID(
    game.Object? owner
);

static EquipmentSystemPlayerData? GetData(game.Object owner) staticRTTI global

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "EquipmentSystem::GetData;GameObject",
    (EquipmentSystem_GetData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EquipmentSystemPlayerData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetData(
    game.Object? owner
);

static void RequestUnequipItem(game.Object owner, game.data.EquipmentArea equipmentArea, int slotIndex) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "EquipmentSystem",
    "EquipmentSystem::RequestUnequipItem;GameObjectgamedataEquipmentAreaInt32",
    (EquipmentSystem_RequestUnequipItem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_RequestUnequipItem(
    game.Object? owner,
    game.data.EquipmentArea equipmentArea,
    int slotIndex
);

static game.data.EquipmentArea[] GetClothingEquipmentAreas() staticRTTI global

static game.data.EquipmentArea GetEquipAreaType(game.ItemID item) staticRTTI global

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "EquipmentSystem::GetEquipAreaType;ItemID",
    (EquipmentSystem_GetEquipAreaType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.EquipmentArea>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetEquipAreaType(
    game.ItemID item
);

static game.ItemID GetSlotOverridenItem(game.Object owner, game.data.EquipmentArea area) staticRTTI global

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "EquipmentSystem::GetSlotOverridenItem;GameObjectgamedataEquipmentArea",
    (EquipmentSystem_GetSlotOverridenItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_GetSlotOverridenItem(
    game.Object? owner,
    game.data.EquipmentArea area
);

static bool HasTag(game.ItemObject item, CName tag) staticRTTI global

Generated hook

re.Hooks.Place(
    "EquipmentSystem",
    "EquipmentSystem::HasTag;ItemObjectCName",
    (EquipmentSystem_HasTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct EquipmentSystem_HasTag(
    game.ItemObject? item,
    CName tag
);