class game.data

GameplayLogicPackage_Record

game.data.GameplayLogicPackage_Record

0 properties
28 functions

Extends game.data.TweakDBRecord IScriptable ISerializable

Properties

None.

Functions

WeakHandle<game.data.GameplayLogicPackageUIData_Record> UIData() RTTI

game.data.GameplayLogicPackageUIData_Record? UIDataHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataGameplayLogicPackage_Record",
    "UIDataHandle",
    (GameplayLogicPackage_Record_UIDataHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.GameplayLogicPackageUIData_Record>();
    }
);

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

void StatPools(out WeakHandle<game.data.StatPool_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataGameplayLogicPackage_Record",
    "StatPools",
    (GameplayLogicPackage_Record_StatPools x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetStatPoolsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataGameplayLogicPackage_Record",
    "GetStatPoolsCount",
    (GameplayLogicPackage_Record_GetStatPoolsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.StatPool_Record> GetStatPoolsItem(int index) RTTI

game.data.StatPool_Record? GetStatPoolsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataGameplayLogicPackage_Record",
    "GetStatPoolsItemHandle",
    (GameplayLogicPackage_Record_GetStatPoolsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.StatPool_Record>();
    }
);

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

bool StatPoolsContains(WeakHandle<game.data.StatPool_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataGameplayLogicPackage_Record",
    "StatPoolsContains",
    (GameplayLogicPackage_Record_StatPoolsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void Effectors(out WeakHandle<game.data.Effector_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataGameplayLogicPackage_Record",
    "Effectors",
    (GameplayLogicPackage_Record_Effectors x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetEffectorsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataGameplayLogicPackage_Record",
    "GetEffectorsCount",
    (GameplayLogicPackage_Record_GetEffectorsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.Effector_Record> GetEffectorsItem(int index) RTTI

game.data.Effector_Record? GetEffectorsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataGameplayLogicPackage_Record",
    "GetEffectorsItemHandle",
    (GameplayLogicPackage_Record_GetEffectorsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Effector_Record>();
    }
);

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

bool EffectorsContains(WeakHandle<game.data.Effector_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataGameplayLogicPackage_Record",
    "EffectorsContains",
    (GameplayLogicPackage_Record_EffectorsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

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

Generated hook

re.Hooks.PlaceVoid(
    "gamedataGameplayLogicPackage_Record",
    "Stats",
    (GameplayLogicPackage_Record_Stats x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetStatsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataGameplayLogicPackage_Record",
    "GetStatsCount",
    (GameplayLogicPackage_Record_GetStatsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

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

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

Generated hook

re.Hooks.Place(
    "gamedataGameplayLogicPackage_Record",
    "GetStatsItemHandle",
    (GameplayLogicPackage_Record_GetStatsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.StatModifier_Record>();
    }
);

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

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

Generated hook

re.Hooks.Place(
    "gamedataGameplayLogicPackage_Record",
    "StatsContains",
    (GameplayLogicPackage_Record_StatsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void Items(out WeakHandle<game.data.InventoryItem_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataGameplayLogicPackage_Record",
    "Items",
    (GameplayLogicPackage_Record_Items x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetItemsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataGameplayLogicPackage_Record",
    "GetItemsCount",
    (GameplayLogicPackage_Record_GetItemsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.InventoryItem_Record> GetItemsItem(int index) RTTI

game.data.InventoryItem_Record? GetItemsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataGameplayLogicPackage_Record",
    "GetItemsItemHandle",
    (GameplayLogicPackage_Record_GetItemsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.InventoryItem_Record>();
    }
);

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

bool ItemsContains(WeakHandle<game.data.InventoryItem_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataGameplayLogicPackage_Record",
    "ItemsContains",
    (GameplayLogicPackage_Record_ItemsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

CName[] AnimationWrapperOverrides() RTTI

int GetAnimationWrapperOverridesCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataGameplayLogicPackage_Record",
    "GetAnimationWrapperOverridesCount",
    (GameplayLogicPackage_Record_GetAnimationWrapperOverridesCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

CName GetAnimationWrapperOverridesItem(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataGameplayLogicPackage_Record",
    "GetAnimationWrapperOverridesItem",
    (GameplayLogicPackage_Record_GetAnimationWrapperOverridesItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

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

bool AnimationWrapperOverridesContains(CName item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataGameplayLogicPackage_Record",
    "AnimationWrapperOverridesContains",
    (GameplayLogicPackage_Record_AnimationWrapperOverridesContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

CName Prereq() RTTI

Generated hook

re.Hooks.Place(
    "gamedataGameplayLogicPackage_Record",
    "Prereq",
    (GameplayLogicPackage_Record_Prereq x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

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

bool Stackable() RTTI

Generated hook

re.Hooks.Place(
    "gamedataGameplayLogicPackage_Record",
    "Stackable",
    (GameplayLogicPackage_Record_Stackable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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