class

AIActionHelper

0 properties
79 functions

Properties

None.

Functions

static int StartCooldown(game.Object self, CName cooldownName, float duration) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::StartCooldown;GameObjectCNameFloat",
    (AIActionHelper_StartCooldown x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_StartCooldown(
    game.Object? self,
    CName cooldownName,
    float duration
);

static game.IBlackboard? GetActionBlackboard(ScriptedPuppet owner) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetActionBlackboard;ScriptedPuppet",
    (AIActionHelper_GetActionBlackboard x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IBlackboard>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetActionBlackboard(
    ScriptedPuppet? owner
);

static bool CheckAbility(WeakHandle<game.Object> objectt, WeakHandle<game.data.GameplayAbility_Record> ability) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::CheckAbility;GameObjectGameplayAbility_Record",
    (AIActionHelper_CheckAbility x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_CheckAbility(
    WeakHandle<game.Object> objectt,
    WeakHandle<game.data.GameplayAbility_Record> ability
);

static void PreloadAllBaseAnimations(WeakHandle<ScriptedPuppet> puppet) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::PreloadAllBaseAnimations;ScriptedPuppet",
    (AIActionHelper_PreloadAllBaseAnimations x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_PreloadAllBaseAnimations(
    WeakHandle<ScriptedPuppet> puppet
);

static bool CheckFlatheadStatPoolRequirements(ScriptGameInstance game, string actionName) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::CheckFlatheadStatPoolRequirements;GameInstancescript_ref<String>",
    (AIActionHelper_CheckFlatheadStatPoolRequirements x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_CheckFlatheadStatPoolRequirements(
    ScriptGameInstance game,
    string actionName
);

static bool GetDistanceRangeFromRingType(WeakHandle<game.data.AIRingType_Record> ringRecord, WeakHandle<game.data.MovementPolicy_Record> condition, out Vector2 distanceRange)

staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetDistanceRangeFromRingType;AIRingType_RecordMovementPolicy_RecordVector2",
    (AIActionHelper_GetDistanceRangeFromRingType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetDistanceRangeFromRingType(
    WeakHandle<game.data.AIRingType_Record> ringRecord,
    WeakHandle<game.data.MovementPolicy_Record> condition,
    Vector2 distanceRange
);

static game.DelayID QueuePullSquadSync(WeakHandle<game.Object> owner, bool postCombatStart) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::QueuePullSquadSync;GameObjectBool",
    (AIActionHelper_QueuePullSquadSync x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.DelayID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_QueuePullSquadSync(
    WeakHandle<game.Object> owner,
    bool postCombatStart
);

static bool PreloadBaseAnimations(WeakHandle<ScriptedPuppet> puppet, bool melee) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::PreloadBaseAnimations;ScriptedPuppetBool",
    (AIActionHelper_PreloadBaseAnimations x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_PreloadBaseAnimations(
    WeakHandle<ScriptedPuppet> puppet,
    bool melee
);

static bool SetCommandCombatTarget(AIbehaviorScriptExecutionContext context, WeakHandle<game.Object> target, bool isPersistant, uint persistenceSource)

staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::SetCommandCombatTarget;ScriptExecutionContextGameObjectBoolUint32",
    (AIActionHelper_SetCommandCombatTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_SetCommandCombatTarget(
    AIbehaviorScriptExecutionContext context,
    WeakHandle<game.Object> target,
    bool isPersistant,
    uint persistenceSource
);

static bool GetItemsFromWeaponSlots(WeakHandle<game.Object> owner, WeakHandle<game.ItemObject>[] items) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetItemsFromWeaponSlots;GameObjectscript_ref<array<ItemObject>>",
    (AIActionHelper_GetItemsFromWeaponSlots x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetItemsFromWeaponSlots(
    WeakHandle<game.Object> owner,
    WeakHandle<game.ItemObject>[] items
);

static bool IsCurrentlyInCoverAttackAction(ScriptedPuppet puppet) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::IsCurrentlyInCoverAttackAction;ScriptedPuppet",
    (AIActionHelper_IsCurrentlyInCoverAttackAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_IsCurrentlyInCoverAttackAction(
    ScriptedPuppet? puppet
);

static void ClearItemsToEquip(WeakHandle<ScriptedPuppet> puppet) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::ClearItemsToEquip;ScriptedPuppet",
    (AIActionHelper_ClearItemsToEquip x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_ClearItemsToEquip(
    WeakHandle<ScriptedPuppet> puppet
);

static float GetCallingAlliesToCombatDelay(bool postCombatStart) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetCallingAlliesToCombatDelay;Bool",
    (AIActionHelper_GetCallingAlliesToCombatDelay x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetCallingAlliesToCombatDelay(
    bool postCombatStart
);

static bool WeaponHasTriggerModes(WeakHandle<game.weapon.Object> weapon, WeakHandle<game.data.WeaponItem_Record> weaponRecord, WeakHandle<game.data.TriggerMode_Record>[] triggerModes)

staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::WeaponHasTriggerModes;WeaponObjectWeaponItem_Recordscript_ref<array<TriggerMode_Record>>",
    (AIActionHelper_WeaponHasTriggerModes x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_WeaponHasTriggerModes(
    WeakHandle<game.weapon.Object> weapon,
    WeakHandle<game.data.WeaponItem_Record> weaponRecord,
    WeakHandle<game.data.TriggerMode_Record>[] triggerModes
);

static void SetFriendlyTargetAllSquadMembers(WeakHandle<game.Object> owner) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::SetFriendlyTargetAllSquadMembers;GameObject",
    (AIActionHelper_SetFriendlyTargetAllSquadMembers x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_SetFriendlyTargetAllSquadMembers(
    WeakHandle<game.Object> owner
);

static bool WeaponHasTriggerMode(WeakHandle<game.weapon.Object> weapon, WeakHandle<game.data.WeaponItem_Record> weaponRecord, WeakHandle<game.data.TriggerMode_Record> triggerMode)

staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::WeaponHasTriggerMode;WeaponObjectWeaponItem_RecordTriggerMode_Record",
    (AIActionHelper_WeaponHasTriggerMode x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_WeaponHasTriggerMode(
    WeakHandle<game.weapon.Object> weapon,
    WeakHandle<game.data.WeaponItem_Record> weaponRecord,
    WeakHandle<game.data.TriggerMode_Record> triggerMode
);

static bool PreloadCoreAnimations(WeakHandle<ScriptedPuppet> puppet, bool melee) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::PreloadCoreAnimations;ScriptedPuppetBool",
    (AIActionHelper_PreloadCoreAnimations x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_PreloadCoreAnimations(
    WeakHandle<ScriptedPuppet> puppet,
    bool melee
);

static void QueuePreloadBaseAnimationsEvent(WeakHandle<ScriptedPuppet> puppet) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::QueuePreloadBaseAnimationsEvent;ScriptedPuppet",
    (AIActionHelper_QueuePreloadBaseAnimationsEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_QueuePreloadBaseAnimationsEvent(
    WeakHandle<ScriptedPuppet> puppet
);

static void SendItemHandling(WeakHandle<game.Object> owner, WeakHandle<game.data.Item_Record> itemRecord, CName animFeatureName, bool equipped)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::SendItemHandling;GameObjectItem_RecordCNameBool",
    (AIActionHelper_SendItemHandling x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_SendItemHandling(
    WeakHandle<game.Object> owner,
    WeakHandle<game.data.Item_Record> itemRecord,
    CName animFeatureName,
    bool equipped
);

static void SetItemsUnequipData(WeakHandle<ScriptedPuppet> puppet, NPCItemToEquip[] itemsToUnequip, bool dropItem) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::SetItemsUnequipData;ScriptedPuppetarray<NPCItemToEquip>Bool",
    (AIActionHelper_SetItemsUnequipData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_SetItemsUnequipData(
    WeakHandle<ScriptedPuppet> puppet,
    NPCItemToEquip[] itemsToUnequip,
    bool dropItem
);

static bool HasWorkspotAICommand(WeakHandle<ScriptedPuppet> owner) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::HasWorkspotAICommand;ScriptedPuppet",
    (AIActionHelper_HasWorkspotAICommand x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_HasWorkspotAICommand(
    WeakHandle<ScriptedPuppet> owner
);

static bool GetDistanceRangeFromRingType(WeakHandle<game.data.AIRingType_Record> ringRecord, out Vector2 distanceRange) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetDistanceRangeFromRingType;AIRingType_RecordVector2",
    (AIActionHelper_GetDistanceRangeFromRingType2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetDistanceRangeFromRingType2(
    WeakHandle<game.data.AIRingType_Record> ringRecord,
    Vector2 distanceRange
);

static bool IsCurrentlyCrouching(ScriptedPuppet puppet) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::IsCurrentlyCrouching;ScriptedPuppet",
    (AIActionHelper_IsCurrentlyCrouching x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_IsCurrentlyCrouching(
    ScriptedPuppet? puppet
);

static bool ClearWorkspotCommand(WeakHandle<ScriptedPuppet> puppet, bool doNotRepeat) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::ClearWorkspotCommand;ScriptedPuppetBool",
    (AIActionHelper_ClearWorkspotCommand x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_ClearWorkspotCommand(
    WeakHandle<ScriptedPuppet> puppet,
    bool doNotRepeat
);

static sense.AdditionalTraceType GetAdditionalTraceTypeValueFromTweakEnum(game.data.AIAdditionalTraceType value) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetAdditionalTraceTypeValueFromTweakEnum;gamedataAIAdditionalTraceType",
    (AIActionHelper_GetAdditionalTraceTypeValueFromTweakEnum x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.sense.AdditionalTraceType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetAdditionalTraceTypeValueFromTweakEnum(
    game.data.AIAdditionalTraceType value
);

static bool WeaponHasTriggerMode(WeakHandle<game.weapon.Object> weapon, game.data.TriggerMode triggerMode) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::WeaponHasTriggerMode;WeaponObjectgamedataTriggerMode",
    (AIActionHelper_WeaponHasTriggerMode2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_WeaponHasTriggerMode2(
    WeakHandle<game.weapon.Object> weapon,
    game.data.TriggerMode triggerMode
);

static bool GetTargetSlotTransform(WeakHandle<game.Object> target, CName slotName, out WorldTransform slotTransform) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetTargetSlotTransform;GameObjectCNameWorldTransform",
    (AIActionHelper_GetTargetSlotTransform x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetTargetSlotTransform(
    WeakHandle<game.Object> target,
    CName slotName,
    WorldTransform slotTransform
);

static game.data.AIRingType_Record? GetLatestActiveRingTypeRecordHelper(game.Object objectt) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetLatestActiveRingTypeRecordHelper;GameObject",
    (AIActionHelper_GetLatestActiveRingTypeRecordHelper x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIRingType_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetLatestActiveRingTypeRecordHelper(
    game.Object? objectt
);

static bool IsPointInRMA(WeakHandle<ScriptedPuppet> ownerPuppet, Vector4 point) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::IsPointInRMA;ScriptedPuppetVector4",
    (AIActionHelper_IsPointInRMA x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_IsPointInRMA(
    WeakHandle<ScriptedPuppet> ownerPuppet,
    Vector4 point
);

static bool GetDistanceAndToleranceFromRingType(WeakHandle<game.data.MovementPolicy_Record> record, out float distance, out float tolerance)

staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetDistanceAndToleranceFromRingType;MovementPolicy_RecordFloatFloat",
    (AIActionHelper_GetDistanceAndToleranceFromRingType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetDistanceAndToleranceFromRingType(
    WeakHandle<game.data.MovementPolicy_Record> record,
    float distance,
    float tolerance
);

static void TargetAllSquadMembers(WeakHandle<game.Object> owner) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::TargetAllSquadMembers;GameObject",
    (AIActionHelper_TargetAllSquadMembers x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_TargetAllSquadMembers(
    WeakHandle<game.Object> owner
);

static game.IBlackboard? GetShootingBlackboard(ScriptedPuppet owner) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetShootingBlackboard;ScriptedPuppet",
    (AIActionHelper_GetShootingBlackboard x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IBlackboard>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetShootingBlackboard(
    ScriptedPuppet? owner
);

static bool ActionDebugHelper(string actionNameCheck, string actionName) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::ActionDebugHelper;script_ref<String>script_ref<String>",
    (AIActionHelper_ActionDebugHelper x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_ActionDebugHelper(
    string actionNameCheck,
    string actionName
);

static void CombatQueriesInit(WeakHandle<ScriptedPuppet> ownerPuppet) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::CombatQueriesInit;ScriptedPuppet",
    (AIActionHelper_CombatQueriesInit x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_CombatQueriesInit(
    WeakHandle<ScriptedPuppet> ownerPuppet
);

static game.DelayID QueueNearbyCombatNotification(WeakHandle<game.Object> owner) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::QueueNearbyCombatNotification;GameObject",
    (AIActionHelper_QueueNearbyCombatNotification x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.DelayID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_QueueNearbyCombatNotification(
    WeakHandle<game.Object> owner
);

static bool WeaponHasTriggerMode(WeakHandle<game.weapon.Object> weapon, WeakHandle<game.data.TriggerMode_Record> triggerMode)

staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::WeaponHasTriggerMode;WeaponObjectTriggerMode_Record",
    (AIActionHelper_WeaponHasTriggerMode3 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_WeaponHasTriggerMode3(
    WeakHandle<game.weapon.Object> weapon,
    WeakHandle<game.data.TriggerMode_Record> triggerMode
);

static void BreakWeaponEffectLoop(game.weapon.Object weapon, CName effectName) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::BreakWeaponEffectLoop;WeaponObjectCName",
    (AIActionHelper_BreakWeaponEffectLoop x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_BreakWeaponEffectLoop(
    game.weapon.Object? weapon,
    CName effectName
);

static void ClearItemsUnequipped(WeakHandle<ScriptedPuppet> puppet) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::ClearItemsUnequipped;ScriptedPuppet",
    (AIActionHelper_ClearItemsUnequipped x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_ClearItemsUnequipped(
    WeakHandle<ScriptedPuppet> puppet
);

static bool GetDistanceRangeFromRingType(WeakHandle<game.data.AIRingType_Record> ringRecord, WeakHandle<game.data.AIOptimalDistanceCond_Record> condition, out Vector2 distanceRange)

staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetDistanceRangeFromRingType;AIRingType_RecordAIOptimalDistanceCond_RecordVector2",
    (AIActionHelper_GetDistanceRangeFromRingType3 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetDistanceRangeFromRingType3(
    WeakHandle<game.data.AIRingType_Record> ringRecord,
    WeakHandle<game.data.AIOptimalDistanceCond_Record> condition,
    Vector2 distanceRange
);

static int StartCooldown(game.Object self, WeakHandle<game.data.AIActionCooldown_Record> record) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::StartCooldown;GameObjectAIActionCooldown_Record",
    (AIActionHelper_StartCooldown2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_StartCooldown2(
    game.Object? self,
    WeakHandle<game.data.AIActionCooldown_Record> record
);

static CName GetCurrentStrongArmsTrailEffect(game.ItemObject weapon) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetCurrentStrongArmsTrailEffect;ItemObject",
    (AIActionHelper_GetCurrentStrongArmsTrailEffect x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetCurrentStrongArmsTrailEffect(
    game.ItemObject? weapon
);

static void QueueSecuritySystemCombatNotification(WeakHandle<game.Object> owner, bool postCombatStart) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::QueueSecuritySystemCombatNotification;GameObjectBool",
    (AIActionHelper_QueueSecuritySystemCombatNotification x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_QueueSecuritySystemCombatNotification(
    WeakHandle<game.Object> owner,
    bool postCombatStart
);

static void KillWeaponEffect(game.weapon.Object weapon, CName effectName) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::KillWeaponEffect;WeaponObjectCName",
    (AIActionHelper_KillWeaponEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_KillWeaponEffect(
    game.weapon.Object? weapon,
    CName effectName
);

static bool IsCommandCombatTargetValid(AIbehaviorScriptExecutionContext context, CName commandName) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::IsCommandCombatTargetValid;ScriptExecutionContextCName",
    (AIActionHelper_IsCommandCombatTargetValid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_IsCommandCombatTargetValid(
    AIbehaviorScriptExecutionContext context,
    CName commandName
);

static bool HasLostTarget(ScriptedPuppet owner, game.Object target) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::HasLostTarget;ScriptedPuppetGameObject",
    (AIActionHelper_HasLostTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_HasLostTarget(
    ScriptedPuppet? owner,
    game.Object? target
);

static bool HasCombatAICommand(WeakHandle<ScriptedPuppet> owner) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::HasCombatAICommand;ScriptedPuppet",
    (AIActionHelper_HasCombatAICommand x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_HasCombatAICommand(
    WeakHandle<ScriptedPuppet> owner
);

static bool GetActiveTopHostilePuppetThreat(ScriptedPuppet puppet, AITrackedLocation threat) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetActiveTopHostilePuppetThreat;ScriptedPuppetscript_ref<TrackedLocation>",
    (AIActionHelper_GetActiveTopHostilePuppetThreat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetActiveTopHostilePuppetThreat(
    ScriptedPuppet? puppet,
    AITrackedLocation threat
);

static bool IsInWorkspot(WeakHandle<game.Object> owner) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::IsInWorkspot;GameObject",
    (AIActionHelper_IsInWorkspot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_IsInWorkspot(
    WeakHandle<game.Object> owner
);

static void ClearItemsForceUnequipped(WeakHandle<ScriptedPuppet> puppet) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::ClearItemsForceUnequipped;ScriptedPuppet",
    (AIActionHelper_ClearItemsForceUnequipped x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_ClearItemsForceUnequipped(
    WeakHandle<ScriptedPuppet> puppet
);

static void QueuePreloadCoreAnimationsEvent(WeakHandle<ScriptedPuppet> puppet) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::QueuePreloadCoreAnimationsEvent;ScriptedPuppet",
    (AIActionHelper_QueuePreloadCoreAnimationsEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_QueuePreloadCoreAnimationsEvent(
    WeakHandle<ScriptedPuppet> puppet
);

static void SetActionExclusivity(game.Object owner, bool active) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::SetActionExclusivity;GameObjectBool",
    (AIActionHelper_SetActionExclusivity x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_SetActionExclusivity(
    game.Object? owner,
    bool active
);

static void PlayWeaponEffect(game.weapon.Object weapon, CName effectName) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::PlayWeaponEffect;WeaponObjectCName",
    (AIActionHelper_PlayWeaponEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_PlayWeaponEffect(
    game.weapon.Object? weapon,
    CName effectName
);

static bool IsCooldownActive(game.Object self, WeakHandle<game.data.AIActionCooldown_Record> record) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::IsCooldownActive;GameObjectAIActionCooldown_Record",
    (AIActionHelper_IsCooldownActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_IsCooldownActive(
    game.Object? self,
    WeakHandle<game.data.AIActionCooldown_Record> record
);

static void UpdateLinkedStatusEffects(WeakHandle<game.Object> owner, LinkedStatusEffect linkedStatusEffect) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::UpdateLinkedStatusEffects;GameObjectscript_ref<LinkedStatusEffect>",
    (AIActionHelper_UpdateLinkedStatusEffects x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_UpdateLinkedStatusEffects(
    WeakHandle<game.Object> owner,
    LinkedStatusEffect linkedStatusEffect
);

static bool GetTargetSlotPosition(WeakHandle<game.Object> target, CName slotName, out Vector4 slotPosition) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetTargetSlotPosition;GameObjectCNameVector4",
    (AIActionHelper_GetTargetSlotPosition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetTargetSlotPosition(
    WeakHandle<game.Object> target,
    CName slotName,
    Vector4 slotPosition
);

static bool WeaponHasTriggerMode(WeakHandle<game.weapon.Object> weapon, WeakHandle<game.data.WeaponItem_Record> weaponRecord, game.data.TriggerMode triggerMode)

staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::WeaponHasTriggerMode;WeaponObjectWeaponItem_RecordgamedataTriggerMode",
    (AIActionHelper_WeaponHasTriggerMode4 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_WeaponHasTriggerMode4(
    WeakHandle<game.weapon.Object> weapon,
    WeakHandle<game.data.WeaponItem_Record> weaponRecord,
    game.data.TriggerMode triggerMode
);

static game.data.TriggerMode GetLastRequestedTriggerMode(WeakHandle<game.weapon.Object> weapon) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetLastRequestedTriggerMode;WeaponObject",
    (AIActionHelper_GetLastRequestedTriggerMode x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.TriggerMode>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetLastRequestedTriggerMode(
    WeakHandle<game.weapon.Object> weapon
);

static game.data.AIRingType_Record? GetLatestActiveRingTypeRecord(WeakHandle<ScriptedPuppet> puppet) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetLatestActiveRingTypeRecord;ScriptedPuppet",
    (AIActionHelper_GetLatestActiveRingTypeRecord x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AIRingType_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetLatestActiveRingTypeRecord(
    WeakHandle<ScriptedPuppet> puppet
);

static bool HasEquippedWeaponWithTag(WeakHandle<game.Object> owner, CName tag) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::HasEquippedWeaponWithTag;GameObjectCName",
    (AIActionHelper_HasEquippedWeaponWithTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_HasEquippedWeaponWithTag(
    WeakHandle<game.Object> owner,
    CName tag
);

static CName GetAnimWrapperNameBasedOnItemID(game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetAnimWrapperNameBasedOnItemID;ItemID",
    (AIActionHelper_GetAnimWrapperNameBasedOnItemID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetAnimWrapperNameBasedOnItemID(
    game.ItemID itemID
);

static bool GetTargetPositionFromPast(WeakHandle<game.Object> target, float delay, out Vector4 position) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetTargetPositionFromPast;GameObjectFloatVector4",
    (AIActionHelper_GetTargetPositionFromPast x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetTargetPositionFromPast(
    WeakHandle<game.Object> target,
    float delay,
    Vector4 position
);

static void AnimationsLoadedSignal(WeakHandle<ScriptedPuppet> ownerPuppet) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::AnimationsLoadedSignal;ScriptedPuppet",
    (AIActionHelper_AnimationsLoadedSignal x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_AnimationsLoadedSignal(
    WeakHandle<ScriptedPuppet> ownerPuppet
);

static bool IsPointInRestrictedMovementArea(WeakHandle<ScriptedPuppet> ownerPuppet, Vector4 point) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::IsPointInRestrictedMovementArea;ScriptedPuppetVector4",
    (AIActionHelper_IsPointInRestrictedMovementArea x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_IsPointInRestrictedMovementArea(
    WeakHandle<ScriptedPuppet> ownerPuppet,
    Vector4 point
);

static bool IsMoveCommand(CName commandName) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::IsMoveCommand;CName",
    (AIActionHelper_IsMoveCommand x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_IsMoveCommand(
    CName commandName
);

static bool GetBaseShootingPatternPackages(WeakHandle<game.data.AIPatternsPackage_Record>[] patternPackages) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetBaseShootingPatternPackages;script_ref<array<AIPatternsPackage_Record>>",
    (AIActionHelper_GetBaseShootingPatternPackages x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetBaseShootingPatternPackages(
    WeakHandle<game.data.AIPatternsPackage_Record>[] patternPackages
);

static void ClearCommandCombatTarget(AIbehaviorScriptExecutionContext context, uint persistenceSource, bool ignoreCombatTargetCommand)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::ClearCommandCombatTarget;ScriptExecutionContextUint32Bool",
    (AIActionHelper_ClearCommandCombatTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_ClearCommandCombatTarget(
    AIbehaviorScriptExecutionContext context,
    uint persistenceSource,
    bool ignoreCombatTargetCommand
);

static bool PreloadAnimations(WeakHandle<ScriptedPuppet> puppet, CName streamingContextName, bool highPriority) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::PreloadAnimations;ScriptedPuppetCNameBool",
    (AIActionHelper_PreloadAnimations x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_PreloadAnimations(
    WeakHandle<ScriptedPuppet> puppet,
    CName streamingContextName,
    bool highPriority
);

static bool IsCurrentlyExposedInCover(ScriptedPuppet puppet) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::IsCurrentlyExposedInCover;ScriptedPuppet",
    (AIActionHelper_IsCurrentlyExposedInCover x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_IsCurrentlyExposedInCover(
    ScriptedPuppet? puppet
);

static void ClearItemsToUnequip(WeakHandle<ScriptedPuppet> puppet) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::ClearItemsToUnequip;ScriptedPuppet",
    (AIActionHelper_ClearItemsToUnequip x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_ClearItemsToUnequip(
    WeakHandle<ScriptedPuppet> puppet
);

static CName GetAnimWrapperNameBasedOnItemTag(game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetAnimWrapperNameBasedOnItemTag;ItemID",
    (AIActionHelper_GetAnimWrapperNameBasedOnItemTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetAnimWrapperNameBasedOnItemTag(
    game.ItemID itemID
);

static bool ShouldShootDirectlyAtTarget(WeakHandle<game.Object> weaponOwner, WeakHandle<game.weapon.Object> weapon, Vector4 targetPosition)

staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::ShouldShootDirectlyAtTarget;GameObjectWeaponObjectVector4",
    (AIActionHelper_ShouldShootDirectlyAtTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_ShouldShootDirectlyAtTarget(
    WeakHandle<game.Object> weaponOwner,
    WeakHandle<game.weapon.Object> weapon,
    Vector4 targetPosition
);

static void SetItemsEquipData(WeakHandle<ScriptedPuppet> puppet, NPCItemToEquip[] itemsToEquip) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::SetItemsEquipData;ScriptedPuppetarray<NPCItemToEquip>",
    (AIActionHelper_SetItemsEquipData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_SetItemsEquipData(
    WeakHandle<ScriptedPuppet> puppet,
    NPCItemToEquip[] itemsToEquip
);

static void ChangeAttitudeToFriendlyAllSquad(WeakHandle<game.Object> owner, ent.EntityID[] squadMembers) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "AIActionHelper",
    "AIActionHelper::ChangeAttitudeToFriendlyAllSquad;GameObjectscript_ref<array<EntityID>>",
    (AIActionHelper_ChangeAttitudeToFriendlyAllSquad x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_ChangeAttitudeToFriendlyAllSquad(
    WeakHandle<game.Object> owner,
    List<ent.EntityID> squadMembers
);

static bool HasFollowerCombatAICommand(WeakHandle<ScriptedPuppet> owner) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::HasFollowerCombatAICommand;ScriptedPuppet",
    (AIActionHelper_HasFollowerCombatAICommand x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_HasFollowerCombatAICommand(
    WeakHandle<ScriptedPuppet> owner
);

static bool TryChangingAttitudeToHostile(ScriptedPuppet owner, game.Object target) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::TryChangingAttitudeToHostile;ScriptedPuppetGameObject",
    (AIActionHelper_TryChangingAttitudeToHostile x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_TryChangingAttitudeToHostile(
    ScriptedPuppet? owner,
    game.Object? target
);

static bool ActionDebugHelper(string actionNameCheck, WeakHandle<ent.Entity> entity, string actionName) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::ActionDebugHelper;script_ref<String>Entityscript_ref<String>",
    (AIActionHelper_ActionDebugHelper2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_ActionDebugHelper2(
    string actionNameCheck,
    WeakHandle<ent.Entity> entity,
    string actionName
);

static bool ActionDebugHelper(WeakHandle<ent.Entity> entity, string actionName) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::ActionDebugHelper;Entityscript_ref<String>",
    (AIActionHelper_ActionDebugHelper3 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_ActionDebugHelper3(
    WeakHandle<ent.Entity> entity,
    string actionName
);

static bool TryStartCombatWithTarget(ScriptedPuppet owner, game.Object target) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::TryStartCombatWithTarget;ScriptedPuppetGameObject",
    (AIActionHelper_TryStartCombatWithTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_TryStartCombatWithTarget(
    ScriptedPuppet? owner,
    game.Object? target
);

static string GetReactionPresetGroup(WeakHandle<ScriptedPuppet> puppet) staticRTTI global

Generated hook

re.Hooks.Place(
    "AIActionHelper",
    "AIActionHelper::GetReactionPresetGroup;ScriptedPuppet",
    (AIActionHelper_GetReactionPresetGroup x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AIActionHelper_GetReactionPresetGroup(
    WeakHandle<ScriptedPuppet> puppet
);