class game.data

AIAction_Record

game.data.AIAction_Record

0 properties
80 functions

Extends game.data.AINode_Record game.data.AIRecord_Record game.data.TweakDBRecord IScriptable ISerializable

Properties

None.

Functions

WeakHandle<game.data.AIActionAnimData_Record> AnimData() RTTI

game.data.AIActionAnimData_Record? AnimDataHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "AnimDataHandle",
    (AIAction_Record_AnimDataHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIActionAnimData_Record>();
    }
);

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

WeakHandle<game.data.AIActionPhase_Record> Recovery() RTTI

game.data.AIActionPhase_Record? RecoveryHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "RecoveryHandle",
    (AIAction_Record_RecoveryHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIActionPhase_Record>();
    }
);

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

WeakHandle<game.data.AIActionPhase_Record> Startup() RTTI

game.data.AIActionPhase_Record? StartupHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "StartupHandle",
    (AIAction_Record_StartupHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIActionPhase_Record>();
    }
);

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

WeakHandle<game.data.AIActionOR_Record> RecoveryEndCondition() RTTI

game.data.AIActionOR_Record? RecoveryEndConditionHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "RecoveryEndConditionHandle",
    (AIAction_Record_RecoveryEndConditionHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIActionOR_Record>();
    }
);

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

WeakHandle<game.data.AIActionOR_Record> StartupRepeatCondition() RTTI

game.data.AIActionOR_Record? StartupRepeatConditionHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "StartupRepeatConditionHandle",
    (AIAction_Record_StartupRepeatConditionHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIActionOR_Record>();
    }
);

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

WeakHandle<game.data.AIActionOR_Record> StartupEndCondition() RTTI

game.data.AIActionOR_Record? StartupEndConditionHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "StartupEndConditionHandle",
    (AIAction_Record_StartupEndConditionHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIActionOR_Record>();
    }
);

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

WeakHandle<game.data.AIActionOR_Record> LoopRepeatCondition() RTTI

game.data.AIActionOR_Record? LoopRepeatConditionHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "LoopRepeatConditionHandle",
    (AIAction_Record_LoopRepeatConditionHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIActionOR_Record>();
    }
);

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

WeakHandle<game.data.AIActionOR_Record> RecoveryRepeatCondition() RTTI

game.data.AIActionOR_Record? RecoveryRepeatConditionHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "RecoveryRepeatConditionHandle",
    (AIAction_Record_RecoveryRepeatConditionHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIActionOR_Record>();
    }
);

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

WeakHandle<game.data.GameplayAbility_Record> Ability() RTTI

game.data.GameplayAbility_Record? AbilityHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "AbilityHandle",
    (AIAction_Record_AbilityHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.GameplayAbility_Record>();
    }
);

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

WeakHandle<game.data.AIActionOR_Record> LoopEndCondition() RTTI

game.data.AIActionOR_Record? LoopEndConditionHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "LoopEndConditionHandle",
    (AIAction_Record_LoopEndConditionHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIActionOR_Record>();
    }
);

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

WeakHandle<game.data.AIActionPhase_Record> Loop() RTTI

game.data.AIActionPhase_Record? LoopHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "LoopHandle",
    (AIAction_Record_LoopHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIActionPhase_Record>();
    }
);

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

void LoopSubActions(out WeakHandle<game.data.AISubAction_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIAction_Record",
    "LoopSubActions",
    (AIAction_Record_LoopSubActions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetLoopSubActionsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "GetLoopSubActionsCount",
    (AIAction_Record_GetLoopSubActionsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AISubAction_Record> GetLoopSubActionsItem(int index) RTTI

game.data.AISubAction_Record? GetLoopSubActionsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "GetLoopSubActionsItemHandle",
    (AIAction_Record_GetLoopSubActionsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AISubAction_Record>();
    }
);

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

bool LoopSubActionsContains(WeakHandle<game.data.AISubAction_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "LoopSubActionsContains",
    (AIAction_Record_LoopSubActionsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void StartupSubActions(out WeakHandle<game.data.AISubAction_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIAction_Record",
    "StartupSubActions",
    (AIAction_Record_StartupSubActions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetStartupSubActionsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "GetStartupSubActionsCount",
    (AIAction_Record_GetStartupSubActionsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AISubAction_Record> GetStartupSubActionsItem(int index) RTTI

game.data.AISubAction_Record? GetStartupSubActionsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "GetStartupSubActionsItemHandle",
    (AIAction_Record_GetStartupSubActionsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AISubAction_Record>();
    }
);

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

bool StartupSubActionsContains(WeakHandle<game.data.AISubAction_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "StartupSubActionsContains",
    (AIAction_Record_StartupSubActionsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void RecoverySubActions(out WeakHandle<game.data.AISubAction_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIAction_Record",
    "RecoverySubActions",
    (AIAction_Record_RecoverySubActions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetRecoverySubActionsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "GetRecoverySubActionsCount",
    (AIAction_Record_GetRecoverySubActionsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AISubAction_Record> GetRecoverySubActionsItem(int index) RTTI

game.data.AISubAction_Record? GetRecoverySubActionsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "GetRecoverySubActionsItemHandle",
    (AIAction_Record_GetRecoverySubActionsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AISubAction_Record>();
    }
);

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

bool RecoverySubActionsContains(WeakHandle<game.data.AISubAction_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "RecoverySubActionsContains",
    (AIAction_Record_RecoverySubActionsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void SubActions(out WeakHandle<game.data.AISubAction_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIAction_Record",
    "SubActions",
    (AIAction_Record_SubActions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetSubActionsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "GetSubActionsCount",
    (AIAction_Record_GetSubActionsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AISubAction_Record> GetSubActionsItem(int index) RTTI

game.data.AISubAction_Record? GetSubActionsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "GetSubActionsItemHandle",
    (AIAction_Record_GetSubActionsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AISubAction_Record>();
    }
);

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

bool SubActionsContains(WeakHandle<game.data.AISubAction_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "SubActionsContains",
    (AIAction_Record_SubActionsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void Cooldowns(out WeakHandle<game.data.AIActionCooldown_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIAction_Record",
    "Cooldowns",
    (AIAction_Record_Cooldowns x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetCooldownsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "GetCooldownsCount",
    (AIAction_Record_GetCooldownsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIActionCooldown_Record> GetCooldownsItem(int index) RTTI

game.data.AIActionCooldown_Record? GetCooldownsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "GetCooldownsItemHandle",
    (AIAction_Record_GetCooldownsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIActionCooldown_Record>();
    }
);

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

bool CooldownsContains(WeakHandle<game.data.AIActionCooldown_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "CooldownsContains",
    (AIAction_Record_CooldownsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void Tickets(out WeakHandle<game.data.AITicketType_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIAction_Record",
    "Tickets",
    (AIAction_Record_Tickets x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetTicketsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "GetTicketsCount",
    (AIAction_Record_GetTicketsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AITicketType_Record> GetTicketsItem(int index) RTTI

game.data.AITicketType_Record? GetTicketsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "GetTicketsItemHandle",
    (AIAction_Record_GetTicketsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AITicketType_Record>();
    }
);

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

bool TicketsContains(WeakHandle<game.data.AITicketType_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "TicketsContains",
    (AIAction_Record_TicketsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void InitCooldowns(out WeakHandle<game.data.AIActionCooldown_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIAction_Record",
    "InitCooldowns",
    (AIAction_Record_InitCooldowns x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetInitCooldownsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "GetInitCooldownsCount",
    (AIAction_Record_GetInitCooldownsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIActionCooldown_Record> GetInitCooldownsItem(int index) RTTI

game.data.AIActionCooldown_Record? GetInitCooldownsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "GetInitCooldownsItemHandle",
    (AIAction_Record_GetInitCooldownsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIActionCooldown_Record>();
    }
);

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

bool InitCooldownsContains(WeakHandle<game.data.AIActionCooldown_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "InitCooldownsContains",
    (AIAction_Record_InitCooldownsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

CName[] Commands() RTTI

int GetCommandsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "GetCommandsCount",
    (AIAction_Record_GetCommandsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

CName GetCommandsItem(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "GetCommandsItem",
    (AIAction_Record_GetCommandsItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

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

bool CommandsContains(CName item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "CommandsContains",
    (AIAction_Record_CommandsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void Lookats(out WeakHandle<game.data.AIActionLookAtData_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIAction_Record",
    "Lookats",
    (AIAction_Record_Lookats x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetLookatsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "GetLookatsCount",
    (AIAction_Record_GetLookatsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIActionLookAtData_Record> GetLookatsItem(int index) RTTI

game.data.AIActionLookAtData_Record? GetLookatsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "GetLookatsItemHandle",
    (AIAction_Record_GetLookatsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIActionLookAtData_Record>();
    }
);

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

bool LookatsContains(WeakHandle<game.data.AIActionLookAtData_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "LookatsContains",
    (AIAction_Record_LookatsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

CName[] AnimationWrapperOverrides() RTTI

int GetAnimationWrapperOverridesCount() RTTI

Generated hook

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

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

CName GetAnimationWrapperOverridesItem(int index) RTTI

Generated hook

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

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

bool AnimationWrapperOverridesContains(CName item) RTTI

Generated hook

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

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

float AllowBlendDuration() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "AllowBlendDuration",
    (AIAction_Record_AllowBlendDuration x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

float TicketAcknowledgeTimeout() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "TicketAcknowledgeTimeout",
    (AIAction_Record_TicketAcknowledgeTimeout x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

float AllowBlendPercCap() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "AllowBlendPercCap",
    (AIAction_Record_AllowBlendPercCap x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

bool SubActionsCanCompleteAction() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "SubActionsCanCompleteAction",
    (AIAction_Record_SubActionsCanCompleteAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool FailIfAnimationNotStreamedIn() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "FailIfAnimationNotStreamedIn",
    (AIAction_Record_FailIfAnimationNotStreamedIn x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool DisableAction() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "DisableAction",
    (AIAction_Record_DisableAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool WaitForAnimationToLoad() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "WaitForAnimationToLoad",
    (AIAction_Record_WaitForAnimationToLoad x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool DisableActionInMultiplayer() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "DisableActionInMultiplayer",
    (AIAction_Record_DisableActionInMultiplayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool CompleteWithFailure() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "CompleteWithFailure",
    (AIAction_Record_CompleteWithFailure x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool RevokingTicketCompletesAction() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIAction_Record",
    "RevokingTicketCompletesAction",
    (AIAction_Record_RevokingTicketCompletesAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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