class game.data

AIActionCondition_Record

game.data.AIActionCondition_Record

0 properties
204 functions

Extends game.data.TweakDBRecord IScriptable ISerializable

Properties

None.

Functions

WeakHandle<game.data.AIBlockCountCond_Record> BlockCount() RTTI

game.data.AIBlockCountCond_Record? BlockCountHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "BlockCountHandle",
    (AIActionCondition_Record_BlockCountHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIBlockCountCond_Record>();
    }
);

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

WeakHandle<game.data.AITargetCond_Record> Target() RTTI

game.data.AITargetCond_Record? TargetHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "TargetHandle",
    (AIActionCondition_Record_TargetHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AITargetCond_Record>();
    }
);

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

WeakHandle<game.data.AIFriendlyFireCond_Record> FriendlyFire() RTTI

game.data.AIFriendlyFireCond_Record? FriendlyFireHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "FriendlyFireHandle",
    (AIActionCondition_Record_FriendlyFireHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIFriendlyFireCond_Record>();
    }
);

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

WeakHandle<game.data.AIPreviousAttackCond_Record> PreviousAttack() RTTI

game.data.AIPreviousAttackCond_Record? PreviousAttackHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "PreviousAttackHandle",
    (AIActionCondition_Record_PreviousAttackHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIPreviousAttackCond_Record>();
    }
);

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

WeakHandle<game.data.AIThrowCond_Record> CanThrow() RTTI

game.data.AIThrowCond_Record? CanThrowHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "CanThrowHandle",
    (AIActionCondition_Record_CanThrowHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIThrowCond_Record>();
    }
);

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

WeakHandle<game.data.AIActionSubCondition_Record> Condition() RTTI

game.data.AIActionSubCondition_Record? ConditionHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "ConditionHandle",
    (AIActionCondition_Record_ConditionHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIActionSubCondition_Record>();
    }
);

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

WeakHandle<game.data.AIOptimalDistanceCond_Record> OptimalDistance() RTTI

game.data.AIOptimalDistanceCond_Record? OptimalDistanceHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "OptimalDistanceHandle",
    (AIActionCondition_Record_OptimalDistanceHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIOptimalDistanceCond_Record>();
    }
);

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

WeakHandle<game.data.AIDodgeCountCond_Record> DodgeCount() RTTI

game.data.AIDodgeCountCond_Record? DodgeCountHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "DodgeCountHandle",
    (AIActionCondition_Record_DodgeCountHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIDodgeCountCond_Record>();
    }
);

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

WeakHandle<game.data.AIWeaponLockedOnTargetCond_Record> WeaponLockedOnTarget() RTTI

game.data.AIWeaponLockedOnTargetCond_Record? WeaponLockedOnTargetHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "WeaponLockedOnTargetHandle",
    (AIActionCondition_Record_WeaponLockedOnTargetHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIWeaponLockedOnTargetCond_Record>();
    }
);

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

WeakHandle<game.data.AICoverCond_Record> Cover() RTTI

game.data.AICoverCond_Record? CoverHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "CoverHandle",
    (AIActionCondition_Record_CoverHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AICoverCond_Record>();
    }
);

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

WeakHandle<game.data.AIGoToCoverCond_Record> GoToCover() RTTI

game.data.AIGoToCoverCond_Record? GoToCoverHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GoToCoverHandle",
    (AIActionCondition_Record_GoToCoverHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIGoToCoverCond_Record>();
    }
);

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

WeakHandle<game.data.AIValidCoversCond_Record> ValidCover() RTTI

game.data.AIValidCoversCond_Record? ValidCoverHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "ValidCoverHandle",
    (AIActionCondition_Record_ValidCoverHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIValidCoversCond_Record>();
    }
);

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

WeakHandle<game.data.AIHitCond_Record> Hit() RTTI

game.data.AIHitCond_Record? HitHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "HitHandle",
    (AIActionCondition_Record_HitHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIHitCond_Record>();
    }
);

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

WeakHandle<game.data.AIWorkspotCond_Record> Workspot() RTTI

game.data.AIWorkspotCond_Record? WorkspotHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "WorkspotHandle",
    (AIActionCondition_Record_WorkspotHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIWorkspotCond_Record>();
    }
);

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

WeakHandle<game.data.AISecurityCond_Record> Security() RTTI

game.data.AISecurityCond_Record? SecurityHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "SecurityHandle",
    (AIActionCondition_Record_SecurityHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AISecurityCond_Record>();
    }
);

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

WeakHandle<game.data.AIHasWeapon_Record> Weapon() RTTI

game.data.AIHasWeapon_Record? WeaponHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "WeaponHandle",
    (AIActionCondition_Record_WeaponHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIHasWeapon_Record>();
    }
);

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

WeakHandle<game.data.AINPCTypeCond_Record> NpcType() RTTI

game.data.AINPCTypeCond_Record? NpcTypeHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "NpcTypeHandle",
    (AIActionCondition_Record_NpcTypeHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AINPCTypeCond_Record>();
    }
);

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

void Lookat(out WeakHandle<game.data.AILookAtCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "Lookat",
    (AIActionCondition_Record_Lookat x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetLookatCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetLookatCount",
    (AIActionCondition_Record_GetLookatCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AILookAtCond_Record> GetLookatItem(int index) RTTI

game.data.AILookAtCond_Record? GetLookatItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetLookatItemHandle",
    (AIActionCondition_Record_GetLookatItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AILookAtCond_Record>();
    }
);

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

bool LookatContains(WeakHandle<game.data.AILookAtCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "LookatContains",
    (AIActionCondition_Record_LookatContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void WeakSpotAND(out WeakHandle<game.data.AIWeakSpotCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "WeakSpotAND",
    (AIActionCondition_Record_WeakSpotAND x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetWeakSpotANDCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetWeakSpotANDCount",
    (AIActionCondition_Record_GetWeakSpotANDCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIWeakSpotCond_Record> GetWeakSpotANDItem(int index) RTTI

game.data.AIWeakSpotCond_Record? GetWeakSpotANDItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetWeakSpotANDItemHandle",
    (AIActionCondition_Record_GetWeakSpotANDItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIWeakSpotCond_Record>();
    }
);

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

bool WeakSpotANDContains(WeakHandle<game.data.AIWeakSpotCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "WeakSpotANDContains",
    (AIActionCondition_Record_WeakSpotANDContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void CommandAND(out WeakHandle<game.data.AICommandCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "CommandAND",
    (AIActionCondition_Record_CommandAND x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetCommandANDCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetCommandANDCount",
    (AIActionCondition_Record_GetCommandANDCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AICommandCond_Record> GetCommandANDItem(int index) RTTI

game.data.AICommandCond_Record? GetCommandANDItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetCommandANDItemHandle",
    (AIActionCondition_Record_GetCommandANDItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AICommandCond_Record>();
    }
);

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

bool CommandANDContains(WeakHandle<game.data.AICommandCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "CommandANDContains",
    (AIActionCondition_Record_CommandANDContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void SlotOR(out WeakHandle<game.data.AISlotCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "SlotOR",
    (AIActionCondition_Record_SlotOR x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetSlotORCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetSlotORCount",
    (AIActionCondition_Record_GetSlotORCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AISlotCond_Record> GetSlotORItem(int index) RTTI

game.data.AISlotCond_Record? GetSlotORItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetSlotORItemHandle",
    (AIActionCondition_Record_GetSlotORItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AISlotCond_Record>();
    }
);

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

bool SlotORContains(WeakHandle<game.data.AISlotCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "SlotORContains",
    (AIActionCondition_Record_SlotORContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void SpatialAND(out WeakHandle<game.data.AISpatialCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "SpatialAND",
    (AIActionCondition_Record_SpatialAND x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetSpatialANDCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetSpatialANDCount",
    (AIActionCondition_Record_GetSpatialANDCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AISpatialCond_Record> GetSpatialANDItem(int index) RTTI

game.data.AISpatialCond_Record? GetSpatialANDItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetSpatialANDItemHandle",
    (AIActionCondition_Record_GetSpatialANDItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AISpatialCond_Record>();
    }
);

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

bool SpatialANDContains(WeakHandle<game.data.AISpatialCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "SpatialANDContains",
    (AIActionCondition_Record_SpatialANDContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void SignalAND(out WeakHandle<game.data.AISignalCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "SignalAND",
    (AIActionCondition_Record_SignalAND x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetSignalANDCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetSignalANDCount",
    (AIActionCondition_Record_GetSignalANDCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AISignalCond_Record> GetSignalANDItem(int index) RTTI

game.data.AISignalCond_Record? GetSignalANDItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetSignalANDItemHandle",
    (AIActionCondition_Record_GetSignalANDItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AISignalCond_Record>();
    }
);

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

bool SignalANDContains(WeakHandle<game.data.AISignalCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "SignalANDContains",
    (AIActionCondition_Record_SignalANDContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void Reaction(out WeakHandle<game.data.AIReactionCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "Reaction",
    (AIActionCondition_Record_Reaction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetReactionCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetReactionCount",
    (AIActionCondition_Record_GetReactionCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIReactionCond_Record> GetReactionItem(int index) RTTI

game.data.AIReactionCond_Record? GetReactionItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetReactionItemHandle",
    (AIActionCondition_Record_GetReactionItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIReactionCond_Record>();
    }
);

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

bool ReactionContains(WeakHandle<game.data.AIReactionCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "ReactionContains",
    (AIActionCondition_Record_ReactionContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void StatPoolOR(out WeakHandle<game.data.AIStatPoolCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "StatPoolOR",
    (AIActionCondition_Record_StatPoolOR x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetStatPoolORCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetStatPoolORCount",
    (AIActionCondition_Record_GetStatPoolORCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIStatPoolCond_Record> GetStatPoolORItem(int index) RTTI

game.data.AIStatPoolCond_Record? GetStatPoolORItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetStatPoolORItemHandle",
    (AIActionCondition_Record_GetStatPoolORItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIStatPoolCond_Record>();
    }
);

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

bool StatPoolORContains(WeakHandle<game.data.AIStatPoolCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "StatPoolORContains",
    (AIActionCondition_Record_StatPoolORContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void StatusEffectOR(out WeakHandle<game.data.AIStatusEffectCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "StatusEffectOR",
    (AIActionCondition_Record_StatusEffectOR x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetStatusEffectORCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetStatusEffectORCount",
    (AIActionCondition_Record_GetStatusEffectORCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIStatusEffectCond_Record> GetStatusEffectORItem(int index) RTTI

game.data.AIStatusEffectCond_Record? GetStatusEffectORItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetStatusEffectORItemHandle",
    (AIActionCondition_Record_GetStatusEffectORItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIStatusEffectCond_Record>();
    }
);

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

bool StatusEffectORContains(WeakHandle<game.data.AIStatusEffectCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "StatusEffectORContains",
    (AIActionCondition_Record_StatusEffectORContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void CalculateLineOfSightVector(out WeakHandle<game.data.AICalculateLineOfSightVector_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "CalculateLineOfSightVector",
    (AIActionCondition_Record_CalculateLineOfSightVector x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetCalculateLineOfSightVectorCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetCalculateLineOfSightVectorCount",
    (AIActionCondition_Record_GetCalculateLineOfSightVectorCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AICalculateLineOfSightVector_Record> GetCalculateLineOfSightVectorItem(int index) RTTI

game.data.AICalculateLineOfSightVector_Record? GetCalculateLineOfSightVectorItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetCalculateLineOfSightVectorItemHandle",
    (AIActionCondition_Record_GetCalculateLineOfSightVectorItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AICalculateLineOfSightVector_Record>();
    }
);

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

bool CalculateLineOfSightVectorContains(WeakHandle<game.data.AICalculateLineOfSightVector_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "CalculateLineOfSightVectorContains",
    (AIActionCondition_Record_CalculateLineOfSightVectorContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void StatPoolAND(out WeakHandle<game.data.AIStatPoolCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "StatPoolAND",
    (AIActionCondition_Record_StatPoolAND x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetStatPoolANDCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetStatPoolANDCount",
    (AIActionCondition_Record_GetStatPoolANDCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIStatPoolCond_Record> GetStatPoolANDItem(int index) RTTI

game.data.AIStatPoolCond_Record? GetStatPoolANDItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetStatPoolANDItemHandle",
    (AIActionCondition_Record_GetStatPoolANDItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIStatPoolCond_Record>();
    }
);

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

bool StatPoolANDContains(WeakHandle<game.data.AIStatPoolCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "StatPoolANDContains",
    (AIActionCondition_Record_StatPoolANDContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void SquadAND(out WeakHandle<game.data.AISquadCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "SquadAND",
    (AIActionCondition_Record_SquadAND x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetSquadANDCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetSquadANDCount",
    (AIActionCondition_Record_GetSquadANDCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AISquadCond_Record> GetSquadANDItem(int index) RTTI

game.data.AISquadCond_Record? GetSquadANDItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetSquadANDItemHandle",
    (AIActionCondition_Record_GetSquadANDItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AISquadCond_Record>();
    }
);

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

bool SquadANDContains(WeakHandle<game.data.AISquadCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "SquadANDContains",
    (AIActionCondition_Record_SquadANDContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void InventoryOR(out WeakHandle<game.data.AIItemCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "InventoryOR",
    (AIActionCondition_Record_InventoryOR x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetInventoryORCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetInventoryORCount",
    (AIActionCondition_Record_GetInventoryORCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIItemCond_Record> GetInventoryORItem(int index) RTTI

game.data.AIItemCond_Record? GetInventoryORItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetInventoryORItemHandle",
    (AIActionCondition_Record_GetInventoryORItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIItemCond_Record>();
    }
);

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

bool InventoryORContains(WeakHandle<game.data.AIItemCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "InventoryORContains",
    (AIActionCondition_Record_InventoryORContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void InventoryAND(out WeakHandle<game.data.AIItemCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "InventoryAND",
    (AIActionCondition_Record_InventoryAND x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetInventoryANDCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetInventoryANDCount",
    (AIActionCondition_Record_GetInventoryANDCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIItemCond_Record> GetInventoryANDItem(int index) RTTI

game.data.AIItemCond_Record? GetInventoryANDItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetInventoryANDItemHandle",
    (AIActionCondition_Record_GetInventoryANDItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIItemCond_Record>();
    }
);

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

bool InventoryANDContains(WeakHandle<game.data.AIItemCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "InventoryANDContains",
    (AIActionCondition_Record_InventoryANDContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void InTacticPosition(out WeakHandle<game.data.AIInTacticPositionCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "InTacticPosition",
    (AIActionCondition_Record_InTacticPosition x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetInTacticPositionCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetInTacticPositionCount",
    (AIActionCondition_Record_GetInTacticPositionCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIInTacticPositionCond_Record> GetInTacticPositionItem(int index) RTTI

game.data.AIInTacticPositionCond_Record? GetInTacticPositionItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetInTacticPositionItemHandle",
    (AIActionCondition_Record_GetInTacticPositionItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIInTacticPositionCond_Record>();
    }
);

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

bool InTacticPositionContains(WeakHandle<game.data.AIInTacticPositionCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "InTacticPositionContains",
    (AIActionCondition_Record_InTacticPositionContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void WeakSpotOR(out WeakHandle<game.data.AIWeakSpotCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "WeakSpotOR",
    (AIActionCondition_Record_WeakSpotOR x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetWeakSpotORCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetWeakSpotORCount",
    (AIActionCondition_Record_GetWeakSpotORCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIWeakSpotCond_Record> GetWeakSpotORItem(int index) RTTI

game.data.AIWeakSpotCond_Record? GetWeakSpotORItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetWeakSpotORItemHandle",
    (AIActionCondition_Record_GetWeakSpotORItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIWeakSpotCond_Record>();
    }
);

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

bool WeakSpotORContains(WeakHandle<game.data.AIWeakSpotCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "WeakSpotORContains",
    (AIActionCondition_Record_WeakSpotORContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void CalculatePath(out WeakHandle<game.data.AICalculatePathCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "CalculatePath",
    (AIActionCondition_Record_CalculatePath x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetCalculatePathCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetCalculatePathCount",
    (AIActionCondition_Record_GetCalculatePathCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AICalculatePathCond_Record> GetCalculatePathItem(int index) RTTI

game.data.AICalculatePathCond_Record? GetCalculatePathItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetCalculatePathItemHandle",
    (AIActionCondition_Record_GetCalculatePathItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AICalculatePathCond_Record>();
    }
);

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

bool CalculatePathContains(WeakHandle<game.data.AICalculatePathCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "CalculatePathContains",
    (AIActionCondition_Record_CalculatePathContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void AmmoCountAND(out WeakHandle<game.data.AIAmmoCountCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "AmmoCountAND",
    (AIActionCondition_Record_AmmoCountAND x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetAmmoCountANDCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetAmmoCountANDCount",
    (AIActionCondition_Record_GetAmmoCountANDCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIAmmoCountCond_Record> GetAmmoCountANDItem(int index) RTTI

game.data.AIAmmoCountCond_Record? GetAmmoCountANDItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetAmmoCountANDItemHandle",
    (AIActionCondition_Record_GetAmmoCountANDItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIAmmoCountCond_Record>();
    }
);

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

bool AmmoCountANDContains(WeakHandle<game.data.AIAmmoCountCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "AmmoCountANDContains",
    (AIActionCondition_Record_AmmoCountANDContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void CommandOR(out WeakHandle<game.data.AICommandCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "CommandOR",
    (AIActionCondition_Record_CommandOR x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetCommandORCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetCommandORCount",
    (AIActionCondition_Record_GetCommandORCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AICommandCond_Record> GetCommandORItem(int index) RTTI

game.data.AICommandCond_Record? GetCommandORItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetCommandORItemHandle",
    (AIActionCondition_Record_GetCommandORItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AICommandCond_Record>();
    }
);

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

bool CommandORContains(WeakHandle<game.data.AICommandCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "CommandORContains",
    (AIActionCondition_Record_CommandORContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void SquadOR(out WeakHandle<game.data.AISquadCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "SquadOR",
    (AIActionCondition_Record_SquadOR x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetSquadORCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetSquadORCount",
    (AIActionCondition_Record_GetSquadORCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AISquadCond_Record> GetSquadORItem(int index) RTTI

game.data.AISquadCond_Record? GetSquadORItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetSquadORItemHandle",
    (AIActionCondition_Record_GetSquadORItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AISquadCond_Record>();
    }
);

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

bool SquadORContains(WeakHandle<game.data.AISquadCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "SquadORContains",
    (AIActionCondition_Record_SquadORContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void SlotAND(out WeakHandle<game.data.AISlotCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "SlotAND",
    (AIActionCondition_Record_SlotAND x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetSlotANDCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetSlotANDCount",
    (AIActionCondition_Record_GetSlotANDCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AISlotCond_Record> GetSlotANDItem(int index) RTTI

game.data.AISlotCond_Record? GetSlotANDItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetSlotANDItemHandle",
    (AIActionCondition_Record_GetSlotANDItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AISlotCond_Record>();
    }
);

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

bool SlotANDContains(WeakHandle<game.data.AISlotCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "SlotANDContains",
    (AIActionCondition_Record_SlotANDContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void RestrictedMovementArea(out WeakHandle<game.data.AIRestrictedMovementAreaCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "RestrictedMovementArea",
    (AIActionCondition_Record_RestrictedMovementArea x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetRestrictedMovementAreaCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetRestrictedMovementAreaCount",
    (AIActionCondition_Record_GetRestrictedMovementAreaCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIRestrictedMovementAreaCond_Record> GetRestrictedMovementAreaItem(int index) RTTI

game.data.AIRestrictedMovementAreaCond_Record? GetRestrictedMovementAreaItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetRestrictedMovementAreaItemHandle",
    (AIActionCondition_Record_GetRestrictedMovementAreaItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIRestrictedMovementAreaCond_Record>();
    }
);

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

bool RestrictedMovementAreaContains(WeakHandle<game.data.AIRestrictedMovementAreaCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "RestrictedMovementAreaContains",
    (AIActionCondition_Record_RestrictedMovementAreaContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void AmmoCountOR(out WeakHandle<game.data.AIAmmoCountCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "AmmoCountOR",
    (AIActionCondition_Record_AmmoCountOR x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetAmmoCountORCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetAmmoCountORCount",
    (AIActionCondition_Record_GetAmmoCountORCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIAmmoCountCond_Record> GetAmmoCountORItem(int index) RTTI

game.data.AIAmmoCountCond_Record? GetAmmoCountORItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetAmmoCountORItemHandle",
    (AIActionCondition_Record_GetAmmoCountORItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIAmmoCountCond_Record>();
    }
);

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

bool AmmoCountORContains(WeakHandle<game.data.AIAmmoCountCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "AmmoCountORContains",
    (AIActionCondition_Record_AmmoCountORContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void MovementOR(out WeakHandle<game.data.AIMovementCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "MovementOR",
    (AIActionCondition_Record_MovementOR x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetMovementORCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetMovementORCount",
    (AIActionCondition_Record_GetMovementORCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIMovementCond_Record> GetMovementORItem(int index) RTTI

game.data.AIMovementCond_Record? GetMovementORItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetMovementORItemHandle",
    (AIActionCondition_Record_GetMovementORItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIMovementCond_Record>();
    }
);

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

bool MovementORContains(WeakHandle<game.data.AIMovementCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "MovementORContains",
    (AIActionCondition_Record_MovementORContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void Cooldown(out WeakHandle<game.data.AICooldownCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "Cooldown",
    (AIActionCondition_Record_Cooldown x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetCooldownCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetCooldownCount",
    (AIActionCondition_Record_GetCooldownCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AICooldownCond_Record> GetCooldownItem(int index) RTTI

game.data.AICooldownCond_Record? GetCooldownItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetCooldownItemHandle",
    (AIActionCondition_Record_GetCooldownItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AICooldownCond_Record>();
    }
);

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

bool CooldownContains(WeakHandle<game.data.AICooldownCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "CooldownContains",
    (AIActionCondition_Record_CooldownContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void SignalOR(out WeakHandle<game.data.AISignalCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "SignalOR",
    (AIActionCondition_Record_SignalOR x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetSignalORCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetSignalORCount",
    (AIActionCondition_Record_GetSignalORCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AISignalCond_Record> GetSignalORItem(int index) RTTI

game.data.AISignalCond_Record? GetSignalORItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetSignalORItemHandle",
    (AIActionCondition_Record_GetSignalORItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AISignalCond_Record>();
    }
);

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

bool SignalORContains(WeakHandle<game.data.AISignalCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "SignalORContains",
    (AIActionCondition_Record_SignalORContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void VehicleOR(out WeakHandle<game.data.AIVehicleCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "VehicleOR",
    (AIActionCondition_Record_VehicleOR x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetVehicleORCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetVehicleORCount",
    (AIActionCondition_Record_GetVehicleORCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIVehicleCond_Record> GetVehicleORItem(int index) RTTI

game.data.AIVehicleCond_Record? GetVehicleORItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetVehicleORItemHandle",
    (AIActionCondition_Record_GetVehicleORItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIVehicleCond_Record>();
    }
);

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

bool VehicleORContains(WeakHandle<game.data.AIVehicleCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "VehicleORContains",
    (AIActionCondition_Record_VehicleORContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void SpatialOR(out WeakHandle<game.data.AISpatialCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "SpatialOR",
    (AIActionCondition_Record_SpatialOR x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetSpatialORCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetSpatialORCount",
    (AIActionCondition_Record_GetSpatialORCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AISpatialCond_Record> GetSpatialORItem(int index) RTTI

game.data.AISpatialCond_Record? GetSpatialORItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetSpatialORItemHandle",
    (AIActionCondition_Record_GetSpatialORItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AISpatialCond_Record>();
    }
);

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

bool SpatialORContains(WeakHandle<game.data.AISpatialCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "SpatialORContains",
    (AIActionCondition_Record_SpatialORContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void MovementAND(out WeakHandle<game.data.AIMovementCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "MovementAND",
    (AIActionCondition_Record_MovementAND x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetMovementANDCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetMovementANDCount",
    (AIActionCondition_Record_GetMovementANDCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIMovementCond_Record> GetMovementANDItem(int index) RTTI

game.data.AIMovementCond_Record? GetMovementANDItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetMovementANDItemHandle",
    (AIActionCondition_Record_GetMovementANDItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIMovementCond_Record>();
    }
);

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

bool MovementANDContains(WeakHandle<game.data.AIMovementCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "MovementANDContains",
    (AIActionCondition_Record_MovementANDContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void StatusEffectAND(out WeakHandle<game.data.AIStatusEffectCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "StatusEffectAND",
    (AIActionCondition_Record_StatusEffectAND x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetStatusEffectANDCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetStatusEffectANDCount",
    (AIActionCondition_Record_GetStatusEffectANDCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIStatusEffectCond_Record> GetStatusEffectANDItem(int index) RTTI

game.data.AIStatusEffectCond_Record? GetStatusEffectANDItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetStatusEffectANDItemHandle",
    (AIActionCondition_Record_GetStatusEffectANDItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIStatusEffectCond_Record>();
    }
);

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

bool StatusEffectANDContains(WeakHandle<game.data.AIStatusEffectCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "StatusEffectANDContains",
    (AIActionCondition_Record_StatusEffectANDContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void VehicleAND(out WeakHandle<game.data.AIVehicleCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "VehicleAND",
    (AIActionCondition_Record_VehicleAND x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetVehicleANDCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetVehicleANDCount",
    (AIActionCondition_Record_GetVehicleANDCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIVehicleCond_Record> GetVehicleANDItem(int index) RTTI

game.data.AIVehicleCond_Record? GetVehicleANDItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetVehicleANDItemHandle",
    (AIActionCondition_Record_GetVehicleANDItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIVehicleCond_Record>();
    }
);

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

bool VehicleANDContains(WeakHandle<game.data.AIVehicleCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "VehicleANDContains",
    (AIActionCondition_Record_VehicleANDContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void Ability(out WeakHandle<game.data.AIAbilityCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "Ability",
    (AIActionCondition_Record_Ability x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetAbilityCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetAbilityCount",
    (AIActionCondition_Record_GetAbilityCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIAbilityCond_Record> GetAbilityItem(int index) RTTI

game.data.AIAbilityCond_Record? GetAbilityItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetAbilityItemHandle",
    (AIActionCondition_Record_GetAbilityItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIAbilityCond_Record>();
    }
);

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

bool AbilityContains(WeakHandle<game.data.AIAbilityCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "AbilityContains",
    (AIActionCondition_Record_AbilityContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void State(out WeakHandle<game.data.AIStateCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "State",
    (AIActionCondition_Record_State x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetStateCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetStateCount",
    (AIActionCondition_Record_GetStateCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AIStateCond_Record> GetStateItem(int index) RTTI

game.data.AIStateCond_Record? GetStateItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetStateItemHandle",
    (AIActionCondition_Record_GetStateItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIStateCond_Record>();
    }
);

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

bool StateContains(WeakHandle<game.data.AIStateCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "StateContains",
    (AIActionCondition_Record_StateContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void Tresspassing(out WeakHandle<game.data.AITresspassingCond_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAIActionCondition_Record",
    "Tresspassing",
    (AIActionCondition_Record_Tresspassing x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int GetTresspassingCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetTresspassingCount",
    (AIActionCondition_Record_GetTresspassingCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.AITresspassingCond_Record> GetTresspassingItem(int index) RTTI

game.data.AITresspassingCond_Record? GetTresspassingItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "GetTresspassingItemHandle",
    (AIActionCondition_Record_GetTresspassingItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AITresspassingCond_Record>();
    }
);

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

bool TresspassingContains(WeakHandle<game.data.AITresspassingCond_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAIActionCondition_Record",
    "TresspassingContains",
    (AIActionCondition_Record_TresspassingContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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