class game.data

Item_Record

game.data.Item_Record

0 properties
189 functions
5 derived classes

Extends game.data.BaseObject_Record game.data.TweakDBRecord IScriptable ISerializable

Derived

game.data.Clothing_Record, game.data.ConsumableItem_Record, game.data.ItemRecipe_Record, game.data.RecipeItem_Record, game.data.WeaponItem_Record

Properties

None.

Functions

string FriendlyName() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "FriendlyName",
    (Item_Record_FriendlyName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_FriendlyName(
    game.data.Item_Record self
);

string IconPath() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "IconPath",
    (Item_Record_IconPath x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_IconPath(
    game.data.Item_Record self
);

string LocalizedName() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "LocalizedName",
    (Item_Record_LocalizedName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_LocalizedName(
    game.data.Item_Record self
);

WeakHandle<game.data.EquipmentMovementSound_Record> MovementSound() RTTI

game.data.EquipmentMovementSound_Record? MovementSoundHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "MovementSoundHandle",
    (Item_Record_MovementSoundHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.EquipmentMovementSound_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_MovementSoundHandle(
    game.data.Item_Record self
);

WeakHandle<game.data.Crosshair_Record> Crosshair() RTTI

game.data.Crosshair_Record? CrosshairHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "CrosshairHandle",
    (Item_Record_CrosshairHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Crosshair_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_CrosshairHandle(
    game.data.Item_Record self
);

WeakHandle<game.data.EquipmentArea_Record> EquipArea() RTTI

game.data.EquipmentArea_Record? EquipAreaHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "EquipAreaHandle",
    (Item_Record_EquipAreaHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.EquipmentArea_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_EquipAreaHandle(
    game.data.Item_Record self
);

WeakHandle<game.data.CraftingPackage_Record> CraftingData() RTTI

game.data.CraftingPackage_Record? CraftingDataHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "CraftingDataHandle",
    (Item_Record_CraftingDataHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.CraftingPackage_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_CraftingDataHandle(
    game.data.Item_Record self
);

WeakHandle<game.data.ItemType_Record> ItemType() RTTI

game.data.ItemType_Record? ItemTypeHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "ItemTypeHandle",
    (Item_Record_ItemTypeHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ItemType_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_ItemTypeHandle(
    game.data.Item_Record self
);

WeakHandle<game.data.ItemBlueprint_Record> Blueprint() RTTI

game.data.ItemBlueprint_Record? BlueprintHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "BlueprintHandle",
    (Item_Record_BlueprintHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ItemBlueprint_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_BlueprintHandle(
    game.data.Item_Record self
);

WeakHandle<game.data.RPGDataPackage_Record> NpcRPGData() RTTI

game.data.RPGDataPackage_Record? NpcRPGDataHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "NpcRPGDataHandle",
    (Item_Record_NpcRPGDataHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.RPGDataPackage_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_NpcRPGDataHandle(
    game.data.Item_Record self
);

WeakHandle<game.data.Quality_Record> Quality() RTTI

game.data.Quality_Record? QualityHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "QualityHandle",
    (Item_Record_QualityHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Quality_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_QualityHandle(
    game.data.Item_Record self
);

WeakHandle<game.data.ParentAttachmentType_Record> ParentAttachmentType() RTTI

game.data.ParentAttachmentType_Record? ParentAttachmentTypeHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "ParentAttachmentTypeHandle",
    (Item_Record_ParentAttachmentTypeHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ParentAttachmentType_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_ParentAttachmentTypeHandle(
    game.data.Item_Record self
);

WeakHandle<game.data.ItemStructure_Record> ItemStructure() RTTI

game.data.ItemStructure_Record? ItemStructureHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "ItemStructureHandle",
    (Item_Record_ItemStructureHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ItemStructure_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_ItemStructureHandle(
    game.data.Item_Record self
);

WeakHandle<game.data.Item_Record> Equivalent() RTTI

game.data.Item_Record? EquivalentHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "EquivalentHandle",
    (Item_Record_EquivalentHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Item_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_EquivalentHandle(
    game.data.Item_Record self
);

WeakHandle<game.data.ItemCategory_Record> ItemCategory() RTTI

game.data.ItemCategory_Record? ItemCategoryHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "ItemCategoryHandle",
    (Item_Record_ItemCategoryHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ItemCategory_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_ItemCategoryHandle(
    game.data.Item_Record self
);

WeakHandle<game.data.CPOItemCategoryBase_Record> CpoItemCategory() RTTI

game.data.CPOItemCategoryBase_Record? CpoItemCategoryHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "CpoItemCategoryHandle",
    (Item_Record_CpoItemCategoryHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.CPOItemCategoryBase_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_CpoItemCategoryHandle(
    game.data.Item_Record self
);

WeakHandle<game.data.UIIcon_Record> Icon() RTTI

game.data.UIIcon_Record? IconHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "IconHandle",
    (Item_Record_IconHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.UIIcon_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_IconHandle(
    game.data.Item_Record self
);

WeakHandle<game.data.Item_Record> Counterpart() RTTI

game.data.Item_Record? CounterpartHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "CounterpartHandle",
    (Item_Record_CounterpartHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Item_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_CounterpartHandle(
    game.data.Item_Record self
);

WeakHandle<game.data.ItemDropSettings_Record> DropSettings() RTTI

game.data.ItemDropSettings_Record? DropSettingsHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "DropSettingsHandle",
    (Item_Record_DropSettingsHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ItemDropSettings_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_DropSettingsHandle(
    game.data.Item_Record self
);

WeakHandle<game.data.ItemAction_Record> ItemSecondaryAction() RTTI

game.data.ItemAction_Record? ItemSecondaryActionHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "ItemSecondaryActionHandle",
    (Item_Record_ItemSecondaryActionHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ItemAction_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_ItemSecondaryActionHandle(
    game.data.Item_Record self
);

WeakHandle<game.data.Minigame_Def_Record> MinigameInstance() RTTI

game.data.Minigame_Def_Record? MinigameInstanceHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "MinigameInstanceHandle",
    (Item_Record_MinigameInstanceHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Minigame_Def_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_MinigameInstanceHandle(
    game.data.Item_Record self
);

WeakHandle<game.data.Item_Record> NextUpgradeItem() RTTI

game.data.Item_Record? NextUpgradeItemHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "NextUpgradeItemHandle",
    (Item_Record_NextUpgradeItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Item_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_NextUpgradeItemHandle(
    game.data.Item_Record self
);

WeakHandle<game.data.Item_Record> SideUpgradeItem() RTTI

game.data.Item_Record? SideUpgradeItemHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "SideUpgradeItemHandle",
    (Item_Record_SideUpgradeItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Item_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_SideUpgradeItemHandle(
    game.data.Item_Record self
);

WeakHandle<game.data.StatsList_Record> OnEquipStats() RTTI

game.data.StatsList_Record? OnEquipStatsHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "OnEquipStatsHandle",
    (Item_Record_OnEquipStatsHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.StatsList_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_OnEquipStatsHandle(
    game.data.Item_Record self
);

void EquipPrereqs(out WeakHandle<game.data.IPrereq_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataItem_Record",
    "EquipPrereqs",
    (Item_Record_EquipPrereqs x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_EquipPrereqs(
    game.data.Item_Record self,
    WeakHandle<game.data.IPrereq_Record>[] outList
);

int GetEquipPrereqsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetEquipPrereqsCount",
    (Item_Record_GetEquipPrereqsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetEquipPrereqsCount(
    game.data.Item_Record self
);

WeakHandle<game.data.IPrereq_Record> GetEquipPrereqsItem(int index) RTTI

game.data.IPrereq_Record? GetEquipPrereqsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetEquipPrereqsItemHandle",
    (Item_Record_GetEquipPrereqsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.IPrereq_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetEquipPrereqsItemHandle(
    game.data.Item_Record self,
    int index
);

bool EquipPrereqsContains(WeakHandle<game.data.IPrereq_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "EquipPrereqsContains",
    (Item_Record_EquipPrereqsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_EquipPrereqsContains(
    game.data.Item_Record self,
    WeakHandle<game.data.IPrereq_Record> item
);

void SlotPartListPreset(out WeakHandle<game.data.SlotItemPartPreset_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataItem_Record",
    "SlotPartListPreset",
    (Item_Record_SlotPartListPreset x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_SlotPartListPreset(
    game.data.Item_Record self,
    WeakHandle<game.data.SlotItemPartPreset_Record>[] outList
);

int GetSlotPartListPresetCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetSlotPartListPresetCount",
    (Item_Record_GetSlotPartListPresetCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetSlotPartListPresetCount(
    game.data.Item_Record self
);

WeakHandle<game.data.SlotItemPartPreset_Record> GetSlotPartListPresetItem(int index) RTTI

game.data.SlotItemPartPreset_Record? GetSlotPartListPresetItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetSlotPartListPresetItemHandle",
    (Item_Record_GetSlotPartListPresetItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.SlotItemPartPreset_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetSlotPartListPresetItemHandle(
    game.data.Item_Record self,
    int index
);

bool SlotPartListPresetContains(WeakHandle<game.data.SlotItemPartPreset_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "SlotPartListPresetContains",
    (Item_Record_SlotPartListPresetContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_SlotPartListPresetContains(
    game.data.Item_Record self,
    WeakHandle<game.data.SlotItemPartPreset_Record> item
);

void EquipAreas(out WeakHandle<game.data.EquipmentArea_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataItem_Record",
    "EquipAreas",
    (Item_Record_EquipAreas x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_EquipAreas(
    game.data.Item_Record self,
    WeakHandle<game.data.EquipmentArea_Record>[] outList
);

int GetEquipAreasCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetEquipAreasCount",
    (Item_Record_GetEquipAreasCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetEquipAreasCount(
    game.data.Item_Record self
);

WeakHandle<game.data.EquipmentArea_Record> GetEquipAreasItem(int index) RTTI

game.data.EquipmentArea_Record? GetEquipAreasItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetEquipAreasItemHandle",
    (Item_Record_GetEquipAreasItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.EquipmentArea_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetEquipAreasItemHandle(
    game.data.Item_Record self,
    int index
);

bool EquipAreasContains(WeakHandle<game.data.EquipmentArea_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "EquipAreasContains",
    (Item_Record_EquipAreasContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_EquipAreasContains(
    game.data.Item_Record self,
    WeakHandle<game.data.EquipmentArea_Record> item
);

void AppearanceSuffixes(out WeakHandle<game.data.ItemsFactoryAppearanceSuffixBase_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataItem_Record",
    "AppearanceSuffixes",
    (Item_Record_AppearanceSuffixes x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_AppearanceSuffixes(
    game.data.Item_Record self,
    WeakHandle<game.data.ItemsFactoryAppearanceSuffixBase_Record>[] outList
);

int GetAppearanceSuffixesCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetAppearanceSuffixesCount",
    (Item_Record_GetAppearanceSuffixesCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetAppearanceSuffixesCount(
    game.data.Item_Record self
);

WeakHandle<game.data.ItemsFactoryAppearanceSuffixBase_Record> GetAppearanceSuffixesItem(int index) RTTI

game.data.ItemsFactoryAppearanceSuffixBase_Record? GetAppearanceSuffixesItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetAppearanceSuffixesItemHandle",
    (Item_Record_GetAppearanceSuffixesItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ItemsFactoryAppearanceSuffixBase_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetAppearanceSuffixesItemHandle(
    game.data.Item_Record self,
    int index
);

bool AppearanceSuffixesContains(WeakHandle<game.data.ItemsFactoryAppearanceSuffixBase_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "AppearanceSuffixesContains",
    (Item_Record_AppearanceSuffixesContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_AppearanceSuffixesContains(
    game.data.Item_Record self,
    WeakHandle<game.data.ItemsFactoryAppearanceSuffixBase_Record> item
);

Vector3[] PreviewBBoxOverride() RTTI

int GetPreviewBBoxOverrideCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetPreviewBBoxOverrideCount",
    (Item_Record_GetPreviewBBoxOverrideCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetPreviewBBoxOverrideCount(
    game.data.Item_Record self
);

Vector3 GetPreviewBBoxOverrideItem(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetPreviewBBoxOverrideItem",
    (Item_Record_GetPreviewBBoxOverrideItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector3>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetPreviewBBoxOverrideItem(
    game.data.Item_Record self,
    int index
);

bool PreviewBBoxOverrideContains(Vector3 item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "PreviewBBoxOverrideContains",
    (Item_Record_PreviewBBoxOverrideContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_PreviewBBoxOverrideContains(
    game.data.Item_Record self,
    Vector3 item
);

void GameplayRestrictions(out WeakHandle<game.data.GameplayRestrictionStatusEffect_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataItem_Record",
    "GameplayRestrictions",
    (Item_Record_GameplayRestrictions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GameplayRestrictions(
    game.data.Item_Record self,
    WeakHandle<game.data.GameplayRestrictionStatusEffect_Record>[] outList
);

int GetGameplayRestrictionsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetGameplayRestrictionsCount",
    (Item_Record_GetGameplayRestrictionsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetGameplayRestrictionsCount(
    game.data.Item_Record self
);

WeakHandle<game.data.GameplayRestrictionStatusEffect_Record> GetGameplayRestrictionsItem(int index) RTTI

game.data.GameplayRestrictionStatusEffect_Record? GetGameplayRestrictionsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetGameplayRestrictionsItemHandle",
    (Item_Record_GetGameplayRestrictionsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.GameplayRestrictionStatusEffect_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetGameplayRestrictionsItemHandle(
    game.data.Item_Record self,
    int index
);

bool GameplayRestrictionsContains(WeakHandle<game.data.GameplayRestrictionStatusEffect_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GameplayRestrictionsContains",
    (Item_Record_GameplayRestrictionsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GameplayRestrictionsContains(
    game.data.Item_Record self,
    WeakHandle<game.data.GameplayRestrictionStatusEffect_Record> item
);

List AppearanceSuffixesOwnerOverride() RTTI

int GetAppearanceSuffixesOwnerOverrideCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetAppearanceSuffixesOwnerOverrideCount",
    (Item_Record_GetAppearanceSuffixesOwnerOverrideCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetAppearanceSuffixesOwnerOverrideCount(
    game.data.Item_Record self
);

bool GetAppearanceSuffixesOwnerOverrideItem(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetAppearanceSuffixesOwnerOverrideItem",
    (Item_Record_GetAppearanceSuffixesOwnerOverrideItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetAppearanceSuffixesOwnerOverrideItem(
    game.data.Item_Record self,
    int index
);

bool AppearanceSuffixesOwnerOverrideContains(bool item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "AppearanceSuffixesOwnerOverrideContains",
    (Item_Record_AppearanceSuffixesOwnerOverrideContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_AppearanceSuffixesOwnerOverrideContains(
    game.data.Item_Record self,
    bool item
);

void OnEquip(out WeakHandle<game.data.GameplayLogicPackage_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataItem_Record",
    "OnEquip",
    (Item_Record_OnEquip x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_OnEquip(
    game.data.Item_Record self,
    WeakHandle<game.data.GameplayLogicPackage_Record>[] outList
);

int GetOnEquipCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetOnEquipCount",
    (Item_Record_GetOnEquipCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetOnEquipCount(
    game.data.Item_Record self
);

WeakHandle<game.data.GameplayLogicPackage_Record> GetOnEquipItem(int index) RTTI

game.data.GameplayLogicPackage_Record? GetOnEquipItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetOnEquipItemHandle",
    (Item_Record_GetOnEquipItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.GameplayLogicPackage_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetOnEquipItemHandle(
    game.data.Item_Record self,
    int index
);

bool OnEquipContains(WeakHandle<game.data.GameplayLogicPackage_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "OnEquipContains",
    (Item_Record_OnEquipContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_OnEquipContains(
    game.data.Item_Record self,
    WeakHandle<game.data.GameplayLogicPackage_Record> item
);

CName[] Tags() RTTI

int GetTagsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetTagsCount",
    (Item_Record_GetTagsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetTagsCount(
    game.data.Item_Record self
);

CName GetTagsItem(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetTagsItem",
    (Item_Record_GetTagsItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetTagsItem(
    game.data.Item_Record self,
    int index
);

bool TagsContains(CName item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "TagsContains",
    (Item_Record_TagsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_TagsContains(
    game.data.Item_Record self,
    CName item
);

void OnAttach(out WeakHandle<game.data.GameplayLogicPackage_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataItem_Record",
    "OnAttach",
    (Item_Record_OnAttach x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_OnAttach(
    game.data.Item_Record self,
    WeakHandle<game.data.GameplayLogicPackage_Record>[] outList
);

int GetOnAttachCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetOnAttachCount",
    (Item_Record_GetOnAttachCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetOnAttachCount(
    game.data.Item_Record self
);

WeakHandle<game.data.GameplayLogicPackage_Record> GetOnAttachItem(int index) RTTI

game.data.GameplayLogicPackage_Record? GetOnAttachItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetOnAttachItemHandle",
    (Item_Record_GetOnAttachItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.GameplayLogicPackage_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetOnAttachItemHandle(
    game.data.Item_Record self,
    int index
);

bool OnAttachContains(WeakHandle<game.data.GameplayLogicPackage_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "OnAttachContains",
    (Item_Record_OnAttachContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_OnAttachContains(
    game.data.Item_Record self,
    WeakHandle<game.data.GameplayLogicPackage_Record> item
);

void SellPrice(out WeakHandle<game.data.StatModifier_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataItem_Record",
    "SellPrice",
    (Item_Record_SellPrice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_SellPrice(
    game.data.Item_Record self,
    WeakHandle<game.data.StatModifier_Record>[] outList
);

int GetSellPriceCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetSellPriceCount",
    (Item_Record_GetSellPriceCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetSellPriceCount(
    game.data.Item_Record self
);

WeakHandle<game.data.StatModifier_Record> GetSellPriceItem(int index) RTTI

game.data.StatModifier_Record? GetSellPriceItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetSellPriceItemHandle",
    (Item_Record_GetSellPriceItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.StatModifier_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetSellPriceItemHandle(
    game.data.Item_Record self,
    int index
);

bool SellPriceContains(WeakHandle<game.data.StatModifier_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "SellPriceContains",
    (Item_Record_SellPriceContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_SellPriceContains(
    game.data.Item_Record self,
    WeakHandle<game.data.StatModifier_Record> item
);

CName[] VisualTags() RTTI

int GetVisualTagsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetVisualTagsCount",
    (Item_Record_GetVisualTagsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetVisualTagsCount(
    game.data.Item_Record self
);

CName GetVisualTagsItem(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetVisualTagsItem",
    (Item_Record_GetVisualTagsItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetVisualTagsItem(
    game.data.Item_Record self,
    int index
);

bool VisualTagsContains(CName item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "VisualTagsContains",
    (Item_Record_VisualTagsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_VisualTagsContains(
    game.data.Item_Record self,
    CName item
);

void BuyPrice(out WeakHandle<game.data.StatModifier_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataItem_Record",
    "BuyPrice",
    (Item_Record_BuyPrice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_BuyPrice(
    game.data.Item_Record self,
    WeakHandle<game.data.StatModifier_Record>[] outList
);

int GetBuyPriceCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetBuyPriceCount",
    (Item_Record_GetBuyPriceCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetBuyPriceCount(
    game.data.Item_Record self
);

WeakHandle<game.data.StatModifier_Record> GetBuyPriceItem(int index) RTTI

game.data.StatModifier_Record? GetBuyPriceItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetBuyPriceItemHandle",
    (Item_Record_GetBuyPriceItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.StatModifier_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetBuyPriceItemHandle(
    game.data.Item_Record self,
    int index
);

bool BuyPriceContains(WeakHandle<game.data.StatModifier_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "BuyPriceContains",
    (Item_Record_BuyPriceContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_BuyPriceContains(
    game.data.Item_Record self,
    WeakHandle<game.data.StatModifier_Record> item
);

void OnLooted(out WeakHandle<game.data.GameplayLogicPackage_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataItem_Record",
    "OnLooted",
    (Item_Record_OnLooted x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_OnLooted(
    game.data.Item_Record self,
    WeakHandle<game.data.GameplayLogicPackage_Record>[] outList
);

int GetOnLootedCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetOnLootedCount",
    (Item_Record_GetOnLootedCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetOnLootedCount(
    game.data.Item_Record self
);

WeakHandle<game.data.GameplayLogicPackage_Record> GetOnLootedItem(int index) RTTI

game.data.GameplayLogicPackage_Record? GetOnLootedItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetOnLootedItemHandle",
    (Item_Record_GetOnLootedItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.GameplayLogicPackage_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetOnLootedItemHandle(
    game.data.Item_Record self,
    int index
);

bool OnLootedContains(WeakHandle<game.data.GameplayLogicPackage_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "OnLootedContains",
    (Item_Record_OnLootedContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_OnLootedContains(
    game.data.Item_Record self,
    WeakHandle<game.data.GameplayLogicPackage_Record> item
);

void PlacementSlots(out WeakHandle<game.data.AttachmentSlot_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataItem_Record",
    "PlacementSlots",
    (Item_Record_PlacementSlots x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_PlacementSlots(
    game.data.Item_Record self,
    WeakHandle<game.data.AttachmentSlot_Record>[] outList
);

int GetPlacementSlotsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetPlacementSlotsCount",
    (Item_Record_GetPlacementSlotsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetPlacementSlotsCount(
    game.data.Item_Record self
);

WeakHandle<game.data.AttachmentSlot_Record> GetPlacementSlotsItem(int index) RTTI

game.data.AttachmentSlot_Record? GetPlacementSlotsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetPlacementSlotsItemHandle",
    (Item_Record_GetPlacementSlotsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AttachmentSlot_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetPlacementSlotsItemHandle(
    game.data.Item_Record self,
    int index
);

bool PlacementSlotsContains(WeakHandle<game.data.AttachmentSlot_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "PlacementSlotsContains",
    (Item_Record_PlacementSlotsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_PlacementSlotsContains(
    game.data.Item_Record self,
    WeakHandle<game.data.AttachmentSlot_Record> item
);

void SlotPartList(out WeakHandle<game.data.SlotItemPartListElement_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataItem_Record",
    "SlotPartList",
    (Item_Record_SlotPartList x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_SlotPartList(
    game.data.Item_Record self,
    WeakHandle<game.data.SlotItemPartListElement_Record>[] outList
);

int GetSlotPartListCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetSlotPartListCount",
    (Item_Record_GetSlotPartListCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetSlotPartListCount(
    game.data.Item_Record self
);

WeakHandle<game.data.SlotItemPartListElement_Record> GetSlotPartListItem(int index) RTTI

game.data.SlotItemPartListElement_Record? GetSlotPartListItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetSlotPartListItemHandle",
    (Item_Record_GetSlotPartListItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.SlotItemPartListElement_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetSlotPartListItemHandle(
    game.data.Item_Record self,
    int index
);

bool SlotPartListContains(WeakHandle<game.data.SlotItemPartListElement_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "SlotPartListContains",
    (Item_Record_SlotPartListContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_SlotPartListContains(
    game.data.Item_Record self,
    WeakHandle<game.data.SlotItemPartListElement_Record> item
);

CName[] HairSkinnedMeshComponents() RTTI

int GetHairSkinnedMeshComponentsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetHairSkinnedMeshComponentsCount",
    (Item_Record_GetHairSkinnedMeshComponentsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetHairSkinnedMeshComponentsCount(
    game.data.Item_Record self
);

CName GetHairSkinnedMeshComponentsItem(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetHairSkinnedMeshComponentsItem",
    (Item_Record_GetHairSkinnedMeshComponentsItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetHairSkinnedMeshComponentsItem(
    game.data.Item_Record self,
    int index
);

bool HairSkinnedMeshComponentsContains(CName item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "HairSkinnedMeshComponentsContains",
    (Item_Record_HairSkinnedMeshComponentsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_HairSkinnedMeshComponentsContains(
    game.data.Item_Record self,
    CName item
);

void Variants(out WeakHandle<game.data.RandomVariant_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataItem_Record",
    "Variants",
    (Item_Record_Variants x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_Variants(
    game.data.Item_Record self,
    WeakHandle<game.data.RandomVariant_Record>[] outList
);

int GetVariantsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetVariantsCount",
    (Item_Record_GetVariantsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetVariantsCount(
    game.data.Item_Record self
);

WeakHandle<game.data.RandomVariant_Record> GetVariantsItem(int index) RTTI

game.data.RandomVariant_Record? GetVariantsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetVariantsItemHandle",
    (Item_Record_GetVariantsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.RandomVariant_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetVariantsItemHandle(
    game.data.Item_Record self,
    int index
);

bool VariantsContains(WeakHandle<game.data.RandomVariant_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "VariantsContains",
    (Item_Record_VariantsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_VariantsContains(
    game.data.Item_Record self,
    WeakHandle<game.data.RandomVariant_Record> item
);

void AttachmentSlots(out WeakHandle<game.data.AttachmentSlot_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataItem_Record",
    "AttachmentSlots",
    (Item_Record_AttachmentSlots x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_AttachmentSlots(
    game.data.Item_Record self,
    WeakHandle<game.data.AttachmentSlot_Record>[] outList
);

int GetAttachmentSlotsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetAttachmentSlotsCount",
    (Item_Record_GetAttachmentSlotsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetAttachmentSlotsCount(
    game.data.Item_Record self
);

WeakHandle<game.data.AttachmentSlot_Record> GetAttachmentSlotsItem(int index) RTTI

game.data.AttachmentSlot_Record? GetAttachmentSlotsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetAttachmentSlotsItemHandle",
    (Item_Record_GetAttachmentSlotsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AttachmentSlot_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetAttachmentSlotsItemHandle(
    game.data.Item_Record self,
    int index
);

bool AttachmentSlotsContains(WeakHandle<game.data.AttachmentSlot_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "AttachmentSlotsContains",
    (Item_Record_AttachmentSlotsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_AttachmentSlotsContains(
    game.data.Item_Record self,
    WeakHandle<game.data.AttachmentSlot_Record> item
);

void RequiredSlots(out WeakHandle<game.data.ItemRequiredSlot_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataItem_Record",
    "RequiredSlots",
    (Item_Record_RequiredSlots x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_RequiredSlots(
    game.data.Item_Record self,
    WeakHandle<game.data.ItemRequiredSlot_Record>[] outList
);

int GetRequiredSlotsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetRequiredSlotsCount",
    (Item_Record_GetRequiredSlotsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetRequiredSlotsCount(
    game.data.Item_Record self
);

WeakHandle<game.data.ItemRequiredSlot_Record> GetRequiredSlotsItem(int index) RTTI

game.data.ItemRequiredSlot_Record? GetRequiredSlotsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetRequiredSlotsItemHandle",
    (Item_Record_GetRequiredSlotsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ItemRequiredSlot_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetRequiredSlotsItemHandle(
    game.data.Item_Record self,
    int index
);

bool RequiredSlotsContains(WeakHandle<game.data.ItemRequiredSlot_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "RequiredSlotsContains",
    (Item_Record_RequiredSlotsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_RequiredSlotsContains(
    game.data.Item_Record self,
    WeakHandle<game.data.ItemRequiredSlot_Record> item
);

void Parts(out WeakHandle<game.data.Item_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataItem_Record",
    "Parts",
    (Item_Record_Parts x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_Parts(
    game.data.Item_Record self,
    WeakHandle<game.data.Item_Record>[] outList
);

int GetPartsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetPartsCount",
    (Item_Record_GetPartsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetPartsCount(
    game.data.Item_Record self
);

WeakHandle<game.data.Item_Record> GetPartsItem(int index) RTTI

game.data.Item_Record? GetPartsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetPartsItemHandle",
    (Item_Record_GetPartsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Item_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetPartsItemHandle(
    game.data.Item_Record self,
    int index
);

bool PartsContains(WeakHandle<game.data.Item_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "PartsContains",
    (Item_Record_PartsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_PartsContains(
    game.data.Item_Record self,
    WeakHandle<game.data.Item_Record> item
);

void Connections(out WeakHandle<game.data.ItemPartConnection_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataItem_Record",
    "Connections",
    (Item_Record_Connections x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_Connections(
    game.data.Item_Record self,
    WeakHandle<game.data.ItemPartConnection_Record>[] outList
);

int GetConnectionsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetConnectionsCount",
    (Item_Record_GetConnectionsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetConnectionsCount(
    game.data.Item_Record self
);

WeakHandle<game.data.ItemPartConnection_Record> GetConnectionsItem(int index) RTTI

game.data.ItemPartConnection_Record? GetConnectionsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetConnectionsItemHandle",
    (Item_Record_GetConnectionsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ItemPartConnection_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetConnectionsItemHandle(
    game.data.Item_Record self,
    int index
);

bool ConnectionsContains(WeakHandle<game.data.ItemPartConnection_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "ConnectionsContains",
    (Item_Record_ConnectionsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_ConnectionsContains(
    game.data.Item_Record self,
    WeakHandle<game.data.ItemPartConnection_Record> item
);

CName[] AnimationParameters() RTTI

int GetAnimationParametersCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetAnimationParametersCount",
    (Item_Record_GetAnimationParametersCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetAnimationParametersCount(
    game.data.Item_Record self
);

CName GetAnimationParametersItem(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GetAnimationParametersItem",
    (Item_Record_GetAnimationParametersItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GetAnimationParametersItem(
    game.data.Item_Record self,
    int index
);

bool AnimationParametersContains(CName item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "AnimationParametersContains",
    (Item_Record_AnimationParametersContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_AnimationParametersContains(
    game.data.Item_Record self,
    CName item
);

CName DisplayName() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "DisplayName",
    (Item_Record_DisplayName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_DisplayName(
    game.data.Item_Record self
);

CName DropObject() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "DropObject",
    (Item_Record_DropObject x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_DropObject(
    game.data.Item_Record self
);

CName AudioName() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "AudioName",
    (Item_Record_AudioName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_AudioName(
    game.data.Item_Record self
);

CName EquipSoundMetadata() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "EquipSoundMetadata",
    (Item_Record_EquipSoundMetadata x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_EquipSoundMetadata(
    game.data.Item_Record self
);

CName AudioSwitchValue() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "AudioSwitchValue",
    (Item_Record_AudioSwitchValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_AudioSwitchValue(
    game.data.Item_Record self
);

CName EntityName() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "EntityName",
    (Item_Record_EntityName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_EntityName(
    game.data.Item_Record self
);

CName AppearanceName() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "AppearanceName",
    (Item_Record_AppearanceName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_AppearanceName(
    game.data.Item_Record self
);

CName AudioSwitchName() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "AudioSwitchName",
    (Item_Record_AudioSwitchName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_AudioSwitchName(
    game.data.Item_Record self
);

CName AnimFeatureName() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "AnimFeatureName",
    (Item_Record_AnimFeatureName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_AnimFeatureName(
    game.data.Item_Record self
);

CName StateMachineName() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "StateMachineName",
    (Item_Record_StateMachineName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_StateMachineName(
    game.data.Item_Record self
);

CName AppearanceResourceName() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "AppearanceResourceName",
    (Item_Record_AppearanceResourceName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_AppearanceResourceName(
    game.data.Item_Record self
);

CName AnimName() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "AnimName",
    (Item_Record_AnimName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_AnimName(
    game.data.Item_Record self
);

red.ResourceReferenceScriptToken AnimSetResource() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "AnimSetResource",
    (Item_Record_AnimSetResource x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.red.ResourceReferenceScriptToken>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_AnimSetResource(
    game.data.Item_Record self
);

CName LocalizedDescription() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "LocalizedDescription",
    (Item_Record_LocalizedDescription x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_LocalizedDescription(
    game.data.Item_Record self
);

CName MovementPattern() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "MovementPattern",
    (Item_Record_MovementPattern x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_MovementPattern(
    game.data.Item_Record self
);

Vector3 CameraForward() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "CameraForward",
    (Item_Record_CameraForward x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector3>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_CameraForward(
    game.data.Item_Record self
);

Vector3 CameraUp() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "CameraUp",
    (Item_Record_CameraUp x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector3>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_CameraUp(
    game.data.Item_Record self
);

float UpgradeCostMult() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "UpgradeCostMult",
    (Item_Record_UpgradeCostMult x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_UpgradeCostMult(
    game.data.Item_Record self
);

int GarmentOffset() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "GarmentOffset",
    (Item_Record_GarmentOffset x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_GarmentOffset(
    game.data.Item_Record self
);

float Mass() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "Mass",
    (Item_Record_Mass x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_Mass(
    game.data.Item_Record self
);

bool PowerLevelDeterminedByParent() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "PowerLevelDeterminedByParent",
    (Item_Record_PowerLevelDeterminedByParent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_PowerLevelDeterminedByParent(
    game.data.Item_Record self
);

bool UseHeadgearGarmentAggregator() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "UseHeadgearGarmentAggregator",
    (Item_Record_UseHeadgearGarmentAggregator x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_UseHeadgearGarmentAggregator(
    game.data.Item_Record self
);

bool IsSingleInstance() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "IsSingleInstance",
    (Item_Record_IsSingleInstance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_IsSingleInstance(
    game.data.Item_Record self
);

bool IsPart() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "IsPart",
    (Item_Record_IsPart x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_IsPart(
    game.data.Item_Record self
);

bool Deprecated() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "Deprecated",
    (Item_Record_Deprecated x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_Deprecated(
    game.data.Item_Record self
);

bool IsGarment() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "IsGarment",
    (Item_Record_IsGarment x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_IsGarment(
    game.data.Item_Record self
);

bool IsCustomizable() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "IsCustomizable",
    (Item_Record_IsCustomizable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_IsCustomizable(
    game.data.Item_Record self
);

bool EnableNpcRPGData() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "EnableNpcRPGData",
    (Item_Record_EnableNpcRPGData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_EnableNpcRPGData(
    game.data.Item_Record self
);

bool IsCached() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "IsCached",
    (Item_Record_IsCached x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_IsCached(
    game.data.Item_Record self
);

bool QualityRestrictedByParent() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "QualityRestrictedByParent",
    (Item_Record_QualityRestrictedByParent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_QualityRestrictedByParent(
    game.data.Item_Record self
);

bool CanDrop() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "CanDrop",
    (Item_Record_CanDrop x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_CanDrop(
    game.data.Item_Record self
);

bool ReplicateWhenNotActive() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "ReplicateWhenNotActive",
    (Item_Record_ReplicateWhenNotActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_ReplicateWhenNotActive(
    game.data.Item_Record self
);

bool UsesVariants() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "UsesVariants",
    (Item_Record_UsesVariants x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_UsesVariants(
    game.data.Item_Record self
);

bool IsCoreCW() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "IsCoreCW",
    (Item_Record_IsCoreCW x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_IsCoreCW(
    game.data.Item_Record self
);

bool UseNewSpawnMethod() RTTI

Generated hook

re.Hooks.Place(
    "gamedataItem_Record",
    "UseNewSpawnMethod",
    (Item_Record_UseNewSpawnMethod x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Item_Record_UseNewSpawnMethod(
    game.data.Item_Record self
);