class game.data

ObjectAction_Record

game.data.ObjectAction_Record

0 properties
72 functions
3 derived classes

Extends game.data.TweakDBRecord IScriptable ISerializable

Derived

game.data.ActionPayment_Record, game.data.ItemAction_Record, game.data.MinigameAction_Record

Properties

None.

Functions

WeakHandle<game.data.ObjectActionGameplayCategory_Record> GameplayCategory() RTTI

game.data.ObjectActionGameplayCategory_Record? GameplayCategoryHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GameplayCategoryHandle",
    (ObjectAction_Record_GameplayCategoryHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ObjectActionGameplayCategory_Record>();
    }
);

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

WeakHandle<game.data.HackCategory_Record> HackCategory() RTTI

game.data.HackCategory_Record? HackCategoryHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "HackCategoryHandle",
    (ObjectAction_Record_HackCategoryHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.HackCategory_Record>();
    }
);

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

WeakHandle<game.data.ObjectActionType_Record> ObjectActionType() RTTI

game.data.ObjectActionType_Record? ObjectActionTypeHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "ObjectActionTypeHandle",
    (ObjectAction_Record_ObjectActionTypeHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ObjectActionType_Record>();
    }
);

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

WeakHandle<game.data.InteractionBase_Record> ObjectActionUI() RTTI

game.data.InteractionBase_Record? ObjectActionUIHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "ObjectActionUIHandle",
    (ObjectAction_Record_ObjectActionUIHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.InteractionBase_Record>();
    }
);

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

WeakHandle<game.data.Cooldown_Record> Cooldown() RTTI

game.data.Cooldown_Record? CooldownHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "CooldownHandle",
    (ObjectAction_Record_CooldownHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Cooldown_Record>();
    }
);

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

WeakHandle<game.data.DeviceHackCategory_Record> DeviceHackCategory() RTTI

game.data.DeviceHackCategory_Record? DeviceHackCategoryHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "DeviceHackCategoryHandle",
    (ObjectAction_Record_DeviceHackCategoryHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.DeviceHackCategory_Record>();
    }
);

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

WeakHandle<game.data.DeviceHackTier_Record> HackTier() RTTI

game.data.DeviceHackTier_Record? HackTierHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "HackTierHandle",
    (ObjectAction_Record_HackTierHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.DeviceHackTier_Record>();
    }
);

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

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

Generated hook

re.Hooks.PlaceVoid(
    "gamedataObjectAction_Record",
    "ActivationTime",
    (ObjectAction_Record_ActivationTime x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetActivationTimeCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetActivationTimeCount",
    (ObjectAction_Record_GetActivationTimeCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

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

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

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetActivationTimeItemHandle",
    (ObjectAction_Record_GetActivationTimeItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.StatModifier_Record>();
    }
);

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

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

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "ActivationTimeContains",
    (ObjectAction_Record_ActivationTimeContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

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

Generated hook

re.Hooks.PlaceVoid(
    "gamedataObjectAction_Record",
    "InterruptionPrereqs",
    (ObjectAction_Record_InterruptionPrereqs x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetInterruptionPrereqsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetInterruptionPrereqsCount",
    (ObjectAction_Record_GetInterruptionPrereqsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

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

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

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetInterruptionPrereqsItemHandle",
    (ObjectAction_Record_GetInterruptionPrereqsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.IPrereq_Record>();
    }
);

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

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

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "InterruptionPrereqsContains",
    (ObjectAction_Record_InterruptionPrereqsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

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

Generated hook

re.Hooks.PlaceVoid(
    "gamedataObjectAction_Record",
    "InstigatorPrereqs",
    (ObjectAction_Record_InstigatorPrereqs x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetInstigatorPrereqsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetInstigatorPrereqsCount",
    (ObjectAction_Record_GetInstigatorPrereqsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

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

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

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetInstigatorPrereqsItemHandle",
    (ObjectAction_Record_GetInstigatorPrereqsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.IPrereq_Record>();
    }
);

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

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

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "InstigatorPrereqsContains",
    (ObjectAction_Record_InstigatorPrereqsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void InstigatorActivePrereqs(out WeakHandle<game.data.ObjectActionPrereq_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataObjectAction_Record",
    "InstigatorActivePrereqs",
    (ObjectAction_Record_InstigatorActivePrereqs x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetInstigatorActivePrereqsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetInstigatorActivePrereqsCount",
    (ObjectAction_Record_GetInstigatorActivePrereqsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.ObjectActionPrereq_Record> GetInstigatorActivePrereqsItem(int index) RTTI

game.data.ObjectActionPrereq_Record? GetInstigatorActivePrereqsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetInstigatorActivePrereqsItemHandle",
    (ObjectAction_Record_GetInstigatorActivePrereqsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ObjectActionPrereq_Record>();
    }
);

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

bool InstigatorActivePrereqsContains(WeakHandle<game.data.ObjectActionPrereq_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "InstigatorActivePrereqsContains",
    (ObjectAction_Record_InstigatorActivePrereqsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void Rewards(out WeakHandle<game.data.RewardBase_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataObjectAction_Record",
    "Rewards",
    (ObjectAction_Record_Rewards x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetRewardsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetRewardsCount",
    (ObjectAction_Record_GetRewardsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.RewardBase_Record> GetRewardsItem(int index) RTTI

game.data.RewardBase_Record? GetRewardsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetRewardsItemHandle",
    (ObjectAction_Record_GetRewardsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.RewardBase_Record>();
    }
);

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

bool RewardsContains(WeakHandle<game.data.RewardBase_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "RewardsContains",
    (ObjectAction_Record_RewardsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void TargetActivePrereqs(out WeakHandle<game.data.ObjectActionPrereq_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataObjectAction_Record",
    "TargetActivePrereqs",
    (ObjectAction_Record_TargetActivePrereqs x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetTargetActivePrereqsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetTargetActivePrereqsCount",
    (ObjectAction_Record_GetTargetActivePrereqsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.ObjectActionPrereq_Record> GetTargetActivePrereqsItem(int index) RTTI

game.data.ObjectActionPrereq_Record? GetTargetActivePrereqsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetTargetActivePrereqsItemHandle",
    (ObjectAction_Record_GetTargetActivePrereqsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ObjectActionPrereq_Record>();
    }
);

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

bool TargetActivePrereqsContains(WeakHandle<game.data.ObjectActionPrereq_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "TargetActivePrereqsContains",
    (ObjectAction_Record_TargetActivePrereqsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void StartEffects(out WeakHandle<game.data.ObjectActionEffect_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataObjectAction_Record",
    "StartEffects",
    (ObjectAction_Record_StartEffects x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetStartEffectsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetStartEffectsCount",
    (ObjectAction_Record_GetStartEffectsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.ObjectActionEffect_Record> GetStartEffectsItem(int index) RTTI

game.data.ObjectActionEffect_Record? GetStartEffectsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetStartEffectsItemHandle",
    (ObjectAction_Record_GetStartEffectsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ObjectActionEffect_Record>();
    }
);

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

bool StartEffectsContains(WeakHandle<game.data.ObjectActionEffect_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "StartEffectsContains",
    (ObjectAction_Record_StartEffectsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

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

Generated hook

re.Hooks.PlaceVoid(
    "gamedataObjectAction_Record",
    "TargetPrereqs",
    (ObjectAction_Record_TargetPrereqs x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetTargetPrereqsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetTargetPrereqsCount",
    (ObjectAction_Record_GetTargetPrereqsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

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

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

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetTargetPrereqsItemHandle",
    (ObjectAction_Record_GetTargetPrereqsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.IPrereq_Record>();
    }
);

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

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

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "TargetPrereqsContains",
    (ObjectAction_Record_TargetPrereqsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

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

Generated hook

re.Hooks.PlaceVoid(
    "gamedataObjectAction_Record",
    "DurationTime",
    (ObjectAction_Record_DurationTime x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetDurationTimeCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetDurationTimeCount",
    (ObjectAction_Record_GetDurationTimeCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

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

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

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetDurationTimeItemHandle",
    (ObjectAction_Record_GetDurationTimeItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.StatModifier_Record>();
    }
);

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

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

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "DurationTimeContains",
    (ObjectAction_Record_DurationTimeContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void CompletionEffects(out WeakHandle<game.data.ObjectActionEffect_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataObjectAction_Record",
    "CompletionEffects",
    (ObjectAction_Record_CompletionEffects x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetCompletionEffectsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetCompletionEffectsCount",
    (ObjectAction_Record_GetCompletionEffectsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.ObjectActionEffect_Record> GetCompletionEffectsItem(int index) RTTI

game.data.ObjectActionEffect_Record? GetCompletionEffectsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetCompletionEffectsItemHandle",
    (ObjectAction_Record_GetCompletionEffectsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ObjectActionEffect_Record>();
    }
);

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

bool CompletionEffectsContains(WeakHandle<game.data.ObjectActionEffect_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "CompletionEffectsContains",
    (ObjectAction_Record_CompletionEffectsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void Costs(out WeakHandle<game.data.ObjectActionCost_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataObjectAction_Record",
    "Costs",
    (ObjectAction_Record_Costs x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetCostsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetCostsCount",
    (ObjectAction_Record_GetCostsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.ObjectActionCost_Record> GetCostsItem(int index) RTTI

game.data.ObjectActionCost_Record? GetCostsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "GetCostsItemHandle",
    (ObjectAction_Record_GetCostsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ObjectActionCost_Record>();
    }
);

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

bool CostsContains(WeakHandle<game.data.ObjectActionCost_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "CostsContains",
    (ObjectAction_Record_CostsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

CName InteractionLayer() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "InteractionLayer",
    (ObjectAction_Record_InteractionLayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

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

CName ActionName() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "ActionName",
    (ObjectAction_Record_ActionName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

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

float Priority() RTTI

Generated hook

re.Hooks.Place(
    "gamedataObjectAction_Record",
    "Priority",
    (ObjectAction_Record_Priority x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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