class game

TargetShootComponent

game.TargetShootComponent

4 properties
25 functions

Extends ent.IComponent IScriptable ISerializable

Properties

Property	Type	Offset
`weaponRecord`	`game.data.WeaponItem_Record?`	`0x0`	scripted
`weaponTDBID`	`TDBID`	`0x10`	scripted
`characterRecord`	`game.data.Character_Record?`	`0x18`	scripted
`characterTDBID`	`TDBID`	`0x28`	scripted

Functions

bool IsTimeBetweenHitsEnabled() RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "IsTimeBetweenHitsEnabled",
    (TargetShootComponent_IsTimeBetweenHitsEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_IsTimeBetweenHitsEnabled(
    game.TargetShootComponent self
);

bool IsDebugEnabled() RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "IsDebugEnabled",
    (TargetShootComponent_IsDebugEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_IsDebugEnabled(
    game.TargetShootComponent self
);

string GetPackageName() RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "GetPackageName",
    (TargetShootComponent_GetPackageName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_GetPackageName(
    game.TargetShootComponent self
);

Vector4 CalculateMissOffset(WeakHandle<game.Object> weaponOwner, WeakHandle<game.weapon.Object> weapon, Vector4 shootAtPointWS, float maxSpread, bool useForcedMissZOffset, float forcedMissZOffset, bool isInLowCover)

RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "CalculateMissOffset",
    (TargetShootComponent_CalculateMissOffset x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_CalculateMissOffset(
    game.TargetShootComponent self,
    WeakHandle<game.Object> weaponOwner,
    WeakHandle<game.weapon.Object> weapon,
    Vector4 shootAtPointWS,
    float maxSpread,
    bool useForcedMissZOffset,
    float forcedMissZOffset,
    bool isInLowCover
);

void SetLastHitTime(float value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTargetShootComponent",
    "SetLastHitTime",
    (TargetShootComponent_SetLastHitTime x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_SetLastHitTime(
    game.TargetShootComponent self,
    float value
);

float GetLastHitTime() RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "GetLastHitTime",
    (TargetShootComponent_GetLastHitTime x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_GetLastHitTime(
    game.TargetShootComponent self
);

float GetBasicGroupCoefficient(WeakHandle<game.Object> weaponOwner) RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "GetBasicGroupCoefficient",
    (TargetShootComponent_GetBasicGroupCoefficient x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_GetBasicGroupCoefficient(
    game.TargetShootComponent self,
    WeakHandle<game.Object> weaponOwner
);

void InsertRecentHitter(WeakHandle<game.Object> weaponOwner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTargetShootComponent",
    "InsertRecentHitter",
    (TargetShootComponent_InsertRecentHitter x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_InsertRecentHitter(
    game.TargetShootComponent self,
    WeakHandle<game.Object> weaponOwner
);

float GetValueFromCurve(CName curveName, float lookupValue) RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "GetValueFromCurve;CNameFloat",
    (TargetShootComponent_GetValueFromCurve x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_GetValueFromCurve(
    game.TargetShootComponent self,
    CName curveName,
    float lookupValue
);

float GetDistanceCoefficientFromCurve(CName curveName, float lookupValue) RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "GetDistanceCoefficientFromCurve;CNameFloat",
    (TargetShootComponent_GetDistanceCoefficientFromCurve x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_GetDistanceCoefficientFromCurve(
    game.TargetShootComponent self,
    CName curveName,
    float lookupValue
);

float GetVisibilityCoefficientFromCurve(CName curveName, float lookupValue) RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "GetVisibilityCoefficientFromCurve;CNameFloat",
    (TargetShootComponent_GetVisibilityCoefficientFromCurve x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_GetVisibilityCoefficientFromCurve(
    game.TargetShootComponent self,
    CName curveName,
    float lookupValue
);

game.Object? GetGameObject() RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "GetGameObject;",
    (TargetShootComponent_GetGameObject x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_GetGameObject(
    game.TargetShootComponent self
);

Vector4 HandleBeingShot(WeakHandle<game.Object> weaponOwner, WeakHandle<game.weapon.Object> weapon, Vector4 shootAtPoint, float maxSpread, float coefficientMultiplier, out bool miss)

RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "HandleBeingShot;GameObjectWeaponObjectVector4FloatFloatBool",
    (TargetShootComponent_HandleBeingShot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_HandleBeingShot(
    game.TargetShootComponent self,
    WeakHandle<game.Object> weaponOwner,
    WeakHandle<game.weapon.Object> weapon,
    Vector4 shootAtPoint,
    float maxSpread,
    float coefficientMultiplier,
    bool miss
);

Vector4 HandleBeingShot(WeakHandle<game.Object> weaponOwner, WeakHandle<game.weapon.Object> weapon, Vector4 shootAtPoint, float maxSpread, float coefficientMultiplier)

RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "HandleBeingShot;GameObjectWeaponObjectVector4FloatFloat",
    (TargetShootComponent_HandleBeingShot2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_HandleBeingShot2(
    game.TargetShootComponent self,
    WeakHandle<game.Object> weaponOwner,
    WeakHandle<game.weapon.Object> weapon,
    Vector4 shootAtPoint,
    float maxSpread,
    float coefficientMultiplier
);

Vector4 HandleMissed(WeakHandle<game.Object> weaponOwner, WeakHandle<game.weapon.Object> weapon, Vector4 shootAtPoint, float maxSpread)

RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "HandleMissed;GameObjectWeaponObjectVector4Float",
    (TargetShootComponent_HandleMissed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_HandleMissed(
    game.TargetShootComponent self,
    WeakHandle<game.Object> weaponOwner,
    WeakHandle<game.weapon.Object> weapon,
    Vector4 shootAtPoint,
    float maxSpread
);

float GetDifficultyLevelCoefficient() RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "GetDifficultyLevelCoefficient;",
    (TargetShootComponent_GetDifficultyLevelCoefficient x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_GetDifficultyLevelCoefficient(
    game.TargetShootComponent self
);

float GetHMGGroupMultiplier() RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "GetHMGGroupMultiplier;",
    (TargetShootComponent_GetHMGGroupMultiplier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_GetHMGGroupMultiplier(
    game.TargetShootComponent self
);

float GetGroupCoefficient(game.Object weaponOwner) RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "GetGroupCoefficient;GameObject",
    (TargetShootComponent_GetGroupCoefficient x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_GetGroupCoefficient(
    game.TargetShootComponent self,
    game.Object? weaponOwner
);

float GetPlayersNumCoefficient(game.Object weaponOwner) RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "GetPlayersNumCoefficient;GameObject",
    (TargetShootComponent_GetPlayersNumCoefficient x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_GetPlayersNumCoefficient(
    game.TargetShootComponent self,
    game.Object? weaponOwner
);

float GetDistanceCoefficient(WeakHandle<game.weapon.Object> weapon, Vector4 targetPosition) RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "GetDistanceCoefficient;WeaponObjectVector4",
    (TargetShootComponent_GetDistanceCoefficient x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

float GetVisibilityCoefficient(game.Object weaponOwner, game.weapon.Object weapon, game.Object target, float visibilityThresholdCoefficient)

RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "GetVisibilityCoefficient;GameObjectWeaponObjectGameObjectFloat",
    (TargetShootComponent_GetVisibilityCoefficient x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_GetVisibilityCoefficient(
    game.TargetShootComponent self,
    game.Object? weaponOwner,
    game.weapon.Object? weapon,
    game.Object? target,
    float visibilityThresholdCoefficient
);

float GetCoverCoefficient(game.Object weaponOwner, game.data.WeaponItem_Record weaponRecord, game.Object target) RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "GetCoverCoefficient;GameObjectWeaponItem_RecordGameObject",
    (TargetShootComponent_GetCoverCoefficient x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_GetCoverCoefficient(
    game.TargetShootComponent self,
    game.Object? weaponOwner,
    game.data.WeaponItem_Record? weaponRecord,
    game.Object? target
);

float GetVisionBlockersCoefficient(game.Object weaponOwner, game.Object target) RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "GetVisionBlockersCoefficient;GameObjectGameObject",
    (TargetShootComponent_GetVisionBlockersCoefficient x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_GetVisionBlockersCoefficient(
    game.TargetShootComponent self,
    game.Object? weaponOwner,
    game.Object? target
);

float CalculateTimeBetweenHits(TimeBetweenHitsParameters paramss) RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "CalculateTimeBetweenHits;script_ref<TimeBetweenHitsParameters>",
    (TargetShootComponent_CalculateTimeBetweenHits x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_CalculateTimeBetweenHits(
    game.TargetShootComponent self,
    TimeBetweenHitsParameters paramss
);

bool ShouldBeHit(game.Object weaponOwner, WeakHandle<game.weapon.Object> weapon, game.data.WeaponItem_Record weaponRecord, float visibilityThresholdCoefficient)

RTTI

Generated hook

re.Hooks.Place(
    "gameTargetShootComponent",
    "ShouldBeHit;GameObjectWeaponObjectWeaponItem_RecordFloat",
    (TargetShootComponent_ShouldBeHit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TargetShootComponent_ShouldBeHit(
    game.TargetShootComponent self,
    game.Object? weaponOwner,
    WeakHandle<game.weapon.Object> weapon,
    game.data.WeaponItem_Record? weaponRecord,
    float visibilityThresholdCoefficient
);