class game.targeting

TargetingSystem

game.targeting.TargetingSystem

0 properties
41 functions

Extends game.ITargetingSystem game.IGameSystem IScriptable ISerializable

Properties

None.

Functions

bool GetTargetParts(WeakHandle<game.Object> instigator, game.TargetSearchQuery query, out game.targeting.TargetPartInfo[] parts)

RTTI

Generated hook

re.Hooks.Place(
    "gametargetingTargetingSystem",
    "GetTargetParts",
    (TargetingSystem_GetTargetParts x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_GetTargetParts(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    game.TargetSearchQuery query,
    game.targeting.TargetPartInfo[] parts
);

game.Object? GetObjectClosestToCrosshair(WeakHandle<game.Object> instigator, out EulerAngles angleDistance, game.TargetSearchQuery query)

RTTI

Generated hook

re.Hooks.Place(
    "gametargetingTargetingSystem",
    "GetObjectClosestToCrosshair",
    (TargetingSystem_GetObjectClosestToCrosshair x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_GetObjectClosestToCrosshair(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    EulerAngles angleDistance,
    game.TargetSearchQuery query
);

ent.IPlacedComponent? GetComponentClosestToCrosshair(WeakHandle<game.Object> instigator, out EulerAngles angleDistance, game.TargetSearchQuery query)

RTTI

Generated hook

re.Hooks.Place(
    "gametargetingTargetingSystem",
    "GetComponentClosestToCrosshair",
    (TargetingSystem_GetComponentClosestToCrosshair x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.IPlacedComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_GetComponentClosestToCrosshair(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    EulerAngles angleDistance,
    game.TargetSearchQuery query
);

game.Object? GetTargetClosestByDistance(WeakHandle<game.Object> instigator, game.TargetSearchQuery query, Vector4 position, game.targeting.TargetPartInfo targetPartInfo)

RTTI

Generated hook

re.Hooks.Place(
    "gametargetingTargetingSystem",
    "GetTargetClosestByDistance",
    (TargetingSystem_GetTargetClosestByDistance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_GetTargetClosestByDistance(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    game.TargetSearchQuery query,
    Vector4 position,
    game.targeting.TargetPartInfo targetPartInfo
);

void GetCrosshairData(WeakHandle<game.Object> instigator, out Vector4 crosshairPosition, out Vector4 crosshairForward) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gametargetingTargetingSystem",
    "GetCrosshairData",
    (TargetingSystem_GetCrosshairData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_GetCrosshairData(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    Vector4 crosshairPosition,
    Vector4 crosshairForward
);

void GetDefaultCrosshairData(WeakHandle<game.Object> instigator, out Vector4 crosshairPosition, out Vector4 crosshairForward)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gametargetingTargetingSystem",
    "GetDefaultCrosshairData",
    (TargetingSystem_GetDefaultCrosshairData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_GetDefaultCrosshairData(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    Vector4 crosshairPosition,
    Vector4 crosshairForward
);

ent.IPositionProvider? GetDefaultCrosshairPositionProvider(WeakHandle<game.Object> instigator, Vector3? offsetEntitySpace)

RTTI

Generated hook

re.Hooks.Place(
    "gametargetingTargetingSystem",
    "GetDefaultCrosshairPositionProvider",
    (TargetingSystem_GetDefaultCrosshairPositionProvider x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.IPositionProvider>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_GetDefaultCrosshairPositionProvider(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    Vector3? offsetEntitySpace
);

ent.IOrientationProvider? GetDefaultCrosshairOrientationProvider(WeakHandle<game.Object> instigator, Quaternion? orientationEntitySpace)

RTTI

Generated hook

re.Hooks.Place(
    "gametargetingTargetingSystem",
    "GetDefaultCrosshairOrientationProvider",
    (TargetingSystem_GetDefaultCrosshairOrientationProvider x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.IOrientationProvider>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_GetDefaultCrosshairOrientationProvider(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    Quaternion? orientationEntitySpace
);

ent.IOrientationProvider? GetOrientationFromCrosshairToTargetOrientationProvider(WeakHandle<game.Object> instigator, WeakHandle<ent.IPlacedComponent> targetComponent, Quaternion? orientationEntitySpace)

RTTI

Generated hook

re.Hooks.Place(
    "gametargetingTargetingSystem",
    "GetOrientationFromCrosshairToTargetOrientationProvider",
    (TargetingSystem_GetOrientationFromCrosshairToTargetOrientationProvider x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.IOrientationProvider>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_GetOrientationFromCrosshairToTargetOrientationProvider(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    WeakHandle<ent.IPlacedComponent> targetComponent,
    Quaternion? orientationEntitySpace
);

game.Object? GetLookAtObject(WeakHandle<game.Object> instigator, bool? withLOS, bool? ignoreTranparent) RTTI

Generated hook

re.Hooks.Place(
    "gametargetingTargetingSystem",
    "GetLookAtObject",
    (TargetingSystem_GetLookAtObject x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_GetLookAtObject(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    bool? withLOS,
    bool? ignoreTranparent
);

WeakHandle<ent.IComponent> GetLookAtComponent(WeakHandle<game.Object> instigator, bool? withLOS, bool? ignoreTranparent) RTTI

Vector4 GetLookAtPosition(WeakHandle<game.Object> instigator, bool? withLOS, bool? ignoreTranparent) RTTI

Generated hook

re.Hooks.Place(
    "gametargetingTargetingSystem",
    "GetLookAtPosition",
    (TargetingSystem_GetLookAtPosition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_GetLookAtPosition(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    bool? withLOS,
    bool? ignoreTranparent
);

Vector4 GetCurrentSpread(WeakHandle<game.Object> instigator) RTTI

Generated hook

re.Hooks.Place(
    "gametargetingTargetingSystem",
    "GetCurrentSpread",
    (TargetingSystem_GetCurrentSpread x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_GetCurrentSpread(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator
);

game.PuppetBlackboardUpdater? GetPuppetBlackboardUpdater() RTTI

Generated hook

re.Hooks.Place(
    "gametargetingTargetingSystem",
    "GetPuppetBlackboardUpdater",
    (TargetingSystem_GetPuppetBlackboardUpdater x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.PuppetBlackboardUpdater>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_GetPuppetBlackboardUpdater(
    game.targeting.TargetingSystem self
);

void AimSnap(WeakHandle<game.Object> instigator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gametargetingTargetingSystem",
    "AimSnap",
    (TargetingSystem_AimSnap x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_AimSnap(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator
);

void LookAt(WeakHandle<game.Object> instigator, out game.aim.AssistAimRequest paramss) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gametargetingTargetingSystem",
    "LookAt",
    (TargetingSystem_LookAt x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_LookAt(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    game.aim.AssistAimRequest paramss
);

void BreakAimSnap(WeakHandle<game.Object> instigator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gametargetingTargetingSystem",
    "BreakAimSnap",
    (TargetingSystem_BreakAimSnap x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_BreakAimSnap(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator
);

void BreakLookAt(WeakHandle<game.Object> instigator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gametargetingTargetingSystem",
    "BreakLookAt",
    (TargetingSystem_BreakLookAt x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_BreakLookAt(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator
);

bool HasAimSnapActive(WeakHandle<game.Object> instigator) RTTI

Generated hook

re.Hooks.Place(
    "gametargetingTargetingSystem",
    "HasAimSnapActive",
    (TargetingSystem_HasAimSnapActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_HasAimSnapActive(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator
);

void OnAimStartBegin(WeakHandle<game.Object> instigator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gametargetingTargetingSystem",
    "OnAimStartBegin",
    (TargetingSystem_OnAimStartBegin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_OnAimStartBegin(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator
);

void OnAimStartEnd(WeakHandle<game.Object> instigator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gametargetingTargetingSystem",
    "OnAimStartEnd",
    (TargetingSystem_OnAimStartEnd x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_OnAimStartEnd(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator
);

void OnAimStop(WeakHandle<game.Object> instigator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gametargetingTargetingSystem",
    "OnAimStop",
    (TargetingSystem_OnAimStop x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_OnAimStop(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator
);

void SetPlayerAimWeaponPositionProvider(WeakHandle<game.Object> instigator, ent.IPositionProvider positionProvider) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gametargetingTargetingSystem",
    "SetPlayerAimWeaponPositionProvider",
    (TargetingSystem_SetPlayerAimWeaponPositionProvider x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_SetPlayerAimWeaponPositionProvider(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    ent.IPositionProvider? positionProvider
);

void SetIsMovingFast(WeakHandle<game.Object> instigator, bool isFast) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gametargetingTargetingSystem",
    "SetIsMovingFast",
    (TargetingSystem_SetIsMovingFast x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_SetIsMovingFast(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    bool isFast
);

void SetAimAssistConfig(WeakHandle<game.Object> owner, TDBID presetId) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gametargetingTargetingSystem",
    "SetAimAssistConfig",
    (TargetingSystem_SetAimAssistConfig x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_SetAimAssistConfig(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> owner,
    TDBID presetId
);

TDBID GetAimAssistConfig(WeakHandle<game.Object> owner) RTTI

Generated hook

re.Hooks.Place(
    "gametargetingTargetingSystem",
    "GetAimAssistConfig",
    (TargetingSystem_GetAimAssistConfig x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_GetAimAssistConfig(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> owner
);

game.Object? GetTrackedTargetObject(WeakHandle<game.Object> instigator) RTTI

Generated hook

re.Hooks.Place(
    "gametargetingTargetingSystem",
    "GetTrackedTargetObject",
    (TargetingSystem_GetTrackedTargetObject x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_GetTrackedTargetObject(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator
);

WeakHandle<game.TargetingComponent> GetTrackedTargetComponent(WeakHandle<game.Object> instigator) RTTI

void ProcessLookAtFilter(WeakHandle<game.Object> instigator, game.targeting.SystemTargetFilter filter) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gametargetingTargetingSystem",
    "ProcessLookAtFilter",
    (TargetingSystem_ProcessLookAtFilter x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_ProcessLookAtFilter(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    game.targeting.SystemTargetFilter? filter
);

game.targeting.SystemTargetFilterTicket RegisterLookAtFilter(WeakHandle<game.Object> instigator, game.targeting.SystemTargetFilter filter)

RTTI

Generated hook

re.Hooks.Place(
    "gametargetingTargetingSystem",
    "RegisterLookAtFilter",
    (TargetingSystem_RegisterLookAtFilter x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.targeting.SystemTargetFilterTicket>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_RegisterLookAtFilter(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    game.targeting.SystemTargetFilter? filter
);

void UnregisterLookAtFilter(WeakHandle<game.Object> instigator, game.targeting.SystemTargetFilterTicket filterTicket) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gametargetingTargetingSystem",
    "UnregisterLookAtFilter",
    (TargetingSystem_UnregisterLookAtFilter x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_UnregisterLookAtFilter(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    game.targeting.SystemTargetFilterTicket filterTicket
);

void AddIgnoredLookAtEntity(WeakHandle<game.Object> instigator, ent.EntityID ignoredEntityId) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gametargetingTargetingSystem",
    "AddIgnoredLookAtEntity",
    (TargetingSystem_AddIgnoredLookAtEntity x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_AddIgnoredLookAtEntity(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    ent.EntityID ignoredEntityId
);

void RemoveIgnoredLookAtEntity(WeakHandle<game.Object> instigator, ent.EntityID ignoredEntityId) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gametargetingTargetingSystem",
    "RemoveIgnoredLookAtEntity",
    (TargetingSystem_RemoveIgnoredLookAtEntity x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_RemoveIgnoredLookAtEntity(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    ent.EntityID ignoredEntityId
);

void AddIgnoredCollisionEntities(WeakHandle<game.Object> entity) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gametargetingTargetingSystem",
    "AddIgnoredCollisionEntities",
    (TargetingSystem_AddIgnoredCollisionEntities x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_AddIgnoredCollisionEntities(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> entity
);

void RemoveIgnoredCollisionEntities(WeakHandle<game.Object> entity) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gametargetingTargetingSystem",
    "RemoveIgnoredCollisionEntities",
    (TargetingSystem_RemoveIgnoredCollisionEntities x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_RemoveIgnoredCollisionEntities(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> entity
);

bool IsVisibleTarget(WeakHandle<game.Object> instigator, WeakHandle<game.Object> target) RTTI

Generated hook

re.Hooks.Place(
    "gametargetingTargetingSystem",
    "IsVisibleTarget",
    (TargetingSystem_IsVisibleTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_IsVisibleTarget(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    WeakHandle<game.Object> target
);

game.TargetingSet GetTargetingSet(WeakHandle<game.Object> instigator, WeakHandle<game.Object> objectt) RTTI

Generated hook

re.Hooks.Place(
    "gametargetingTargetingSystem",
    "GetTargetingSet",
    (TargetingSystem_GetTargetingSet x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TargetingSet>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_GetTargetingSet(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    WeakHandle<game.Object> objectt
);

WeakHandle<game.TargetingComponent> GetBestComponentOnTargetObject(Vector4 shootStartPosition, Vector4 shootStartForward, WeakHandle<game.Object> target, game.targeting.SystemScriptFilter componentFilter) RTTI

bool IsAnyEnemyVisible(WeakHandle<game.Object> instigator, float? distance) RTTI

Generated hook

re.Hooks.Place(
    "gametargetingTargetingSystem",
    "IsAnyEnemyVisible",
    (TargetingSystem_IsAnyEnemyVisible x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_IsAnyEnemyVisible(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    float? distance
);

bool IsAnyEnemyOrSensorVisible(WeakHandle<game.Object> instigator, float? distance) RTTI

Generated hook

re.Hooks.Place(
    "gametargetingTargetingSystem",
    "IsAnyEnemyOrSensorVisible",
    (TargetingSystem_IsAnyEnemyOrSensorVisible x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_IsAnyEnemyOrSensorVisible(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    float? distance
);

bool IsAnyActiveVehicleVisible(WeakHandle<game.Object> instigator, float? distance) RTTI

Generated hook

re.Hooks.Place(
    "gametargetingTargetingSystem",
    "IsAnyActiveVehicleVisible",
    (TargetingSystem_IsAnyActiveVehicleVisible x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetingSystem_IsAnyActiveVehicleVisible(
    game.targeting.TargetingSystem self,
    WeakHandle<game.Object> instigator,
    float? distance
);