class game.weapon

Object

game.weapon.Object

25 properties
158 functions
8 derived classes

Extends game.ItemObject game.TimeDilatable game.Object ent.GameEntity ent.Entity IScriptable ISerializable

Derived

AntiRadar, ClaymoreMine, Katana, MineDispenser, MuteArm, ThrowableWeaponObject, drill.Machine, grenade.Spawner

Properties

Property	Type	Offset
`hasOverheat`	`bool`	`0x100`	scripted
`overheatEffectBlackboard`	`world.EffectBlackboard?`	`0x108`	scripted
`overheatListener`	`OverheatStatListener?`	`0x118`	scripted
`overheatDelaySent`	`bool`	`0x128`	scripted
`chargeEffectBlackboard`	`world.EffectBlackboard?`	`0x130`	scripted
`chargeStatListener`	`WeaponChargeStatListener?`	`0x140`	scripted
`triggerEffectName`	`CName`	`0x150`	scripted
`meleeHitEffectBlackboard`	`world.EffectBlackboard?`	`0x158`	scripted
`meleeHitEffectValue`	`float`	`0x168`	scripted
`damageTypeListener`	`DamageStatListener?`	`0x170`	scripted
`trailName`	`string`	`0x180`	scripted
`maxChargeThreshold`	`float`	`0x1A0`	scripted
`animOwner`	`int`	`0x1A4`	scripted
`perfectChargeStarted`	`bool`	`0x1A8`	scripted
`perfectChargeReached`	`bool`	`0x1A9`	scripted
`perfectChargeShot`	`bool`	`0x1AA`	scripted
`lowAmmoEffectActive`	`bool`	`0x1AB`	scripted
`hasSecondaryTriggerMode`	`bool`	`0x1AC`	scripted
`weaponRecord`	`game.data.WeaponItem_Record?`	`0x1B0`	scripted
`isHeavyWeapon`	`bool`	`0x1C0`	scripted
`isMeleeWeapon`	`bool`	`0x1C1`	scripted
`isRangedWeapon`	`bool`	`0x1C2`	scripted
`isShotgunWeapon`	`bool`	`0x1C3`	scripted
`AIBlackboard`	`game.IBlackboard?`	`0x1C8`	scripted
`isCharged`	`bool`	`0x1D8`	scripted

Functions

game.IAttack?[] GetAttacks() RTTI

game.IAttack? GetAttack(CName recordName) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetAttack",
    (Object_GetAttack x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IAttack>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetAttack(
    game.weapon.Object self,
    CName recordName
);

game.IAttack? GetCurrentAttack() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetCurrentAttack",
    (Object_GetCurrentAttack x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IAttack>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetCurrentAttack(
    game.weapon.Object self
);

game.data.TriggerMode_Record? GetCurrentTriggerMode() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetCurrentTriggerMode",
    (Object_GetCurrentTriggerMode x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.TriggerMode_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetCurrentTriggerMode(
    game.weapon.Object self
);

WeakHandle<game.weapon.FxPackage> GetFxPackage() RTTI
WeakHandle<game.weapon.FxPackage> GetFxPackageQuickMelee() RTTI

game.IBlackboard? GetSharedData() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetSharedData",
    (Object_GetSharedData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IBlackboard>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetSharedData(
    game.weapon.Object self
);

int GetTotalAmmoCount() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetTotalAmmoCount",
    (Object_GetTotalAmmoCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetTotalAmmoCount(
    game.weapon.Object self
);

game.data.TriggerMode_Record?[] GetTriggerModes() RTTI

bool HasAmmoChangeRequest() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "HasAmmoChangeRequest",
    (Object_HasAmmoChangeRequest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasAmmoChangeRequest(
    game.weapon.Object self
);

bool HasPendingReload() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "HasPendingReload",
    (Object_HasPendingReload x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasPendingReload(
    game.weapon.Object self
);

bool SetAttack(TDBID attackID) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "SetAttack",
    (Object_SetAttack x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SetAttack(
    game.weapon.Object self,
    TDBID attackID
);

bool OverrideRangedAttackPackage(WeakHandle<game.data.RangedAttackPackage_Record> package) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "OverrideRangedAttackPackage",
    (Object_OverrideRangedAttackPackage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OverrideRangedAttackPackage(
    game.weapon.Object self,
    WeakHandle<game.data.RangedAttackPackage_Record> package
);

bool DefaultRangedAttackPackage() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "DefaultRangedAttackPackage",
    (Object_DefaultRangedAttackPackage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_DefaultRangedAttackPackage(
    game.weapon.Object self
);

float StartReload(float? durationOverride) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "StartReload",
    (Object_StartReload x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_StartReload(
    game.weapon.Object self,
    float? durationOverride
);

void StopReload(game.weapon.ReloadStatus? reloadStatus) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "StopReload",
    (Object_StopReload x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_StopReload(
    game.weapon.Object self,
    game.weapon.ReloadStatus? reloadStatus
);

void AI_ShootAt(ent.IPositionProvider targetPositionProvider, game.Object targetObject, WeakHandle<game.Object> instigator, ushort ammoCost, game.projectile.WeaponParams projectileParams, byte projectilesPerShot, float charge, float? maxSpread, Vector4? muzzleOffset)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "AI_ShootAt",
    (Object_AI_ShootAt x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_AI_ShootAt(
    game.weapon.Object self,
    ent.IPositionProvider? targetPositionProvider,
    game.Object? targetObject,
    WeakHandle<game.Object> instigator,
    ushort ammoCost,
    game.projectile.WeaponParams projectileParams,
    byte projectilesPerShot,
    float charge,
    float? maxSpread,
    Vector4? muzzleOffset
);

void AI_ShootForwards(WeakHandle<game.Object> instigator, ushort ammoCost, game.projectile.WeaponParams projectileParams, byte projectilesPerShot, float charge, Vector4? overridePos, Vector4? overrideForward, Vector4? muzzleOffset)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "AI_ShootForwards",
    (Object_AI_ShootForwards x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_AI_ShootForwards(
    game.weapon.Object self,
    WeakHandle<game.Object> instigator,
    ushort ammoCost,
    game.projectile.WeaponParams projectileParams,
    byte projectilesPerShot,
    float charge,
    Vector4? overridePos,
    Vector4? overrideForward,
    Vector4? muzzleOffset
);

void AI_ShootSelfOffScreen(game.Puppet targetObject, ushort ammoCost, game.projectile.WeaponParams projectileParams, byte projectilesPerShot, float charge)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "AI_ShootSelfOffScreen",
    (Object_AI_ShootSelfOffScreen x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_AI_ShootSelfOffScreen(
    game.weapon.Object self,
    game.Puppet? targetObject,
    ushort ammoCost,
    game.projectile.WeaponParams projectileParams,
    byte projectilesPerShot,
    float charge
);

void AI_SetAttackData(WeakHandle<game.IAttack> attack) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "AI_SetAttackData",
    (Object_AI_SetAttackData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_AI_SetAttackData(
    game.weapon.Object self,
    WeakHandle<game.IAttack> attack
);

void AI_PlayChargeStartedSound() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "AI_PlayChargeStartedSound",
    (Object_AI_PlayChargeStartedSound x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_AI_PlayChargeStartedSound(
    game.weapon.Object self
);

void AI_PlayMeleeAttackSound(bool isQuickMelee) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "AI_PlayMeleeAttackSound",
    (Object_AI_PlayMeleeAttackSound x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_AI_PlayMeleeAttackSound(
    game.weapon.Object self,
    bool isQuickMelee
);

void SetTriggerDown(bool triggerDown) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "SetTriggerDown",
    (Object_SetTriggerDown x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SetTriggerDown(
    game.weapon.Object self,
    bool triggerDown
);

void PrepareContinuousAttack(Vector4 startPos, Vector4 startDir) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "PrepareContinuousAttack",
    (Object_PrepareContinuousAttack x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_PrepareContinuousAttack(
    game.weapon.Object self,
    Vector4 startPos,
    Vector4 startDir
);

bool StartPreparedContinuousAttack() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "StartPreparedContinuousAttack",
    (Object_StartPreparedContinuousAttack x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_StartPreparedContinuousAttack(
    game.weapon.Object self
);

bool StartContinuousAttack(Vector4 startPos, Vector4 startDir) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "StartContinuousAttack",
    (Object_StartContinuousAttack x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_StartContinuousAttack(
    game.weapon.Object self,
    Vector4 startPos,
    Vector4 startDir
);

void StopContinuousAttack() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "StopContinuousAttack",
    (Object_StopContinuousAttack x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_StopContinuousAttack(
    game.weapon.Object self
);

bool IsContinuousAttackStarted() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "IsContinuousAttackStarted",
    (Object_IsContinuousAttackStarted x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsContinuousAttackStarted(
    game.weapon.Object self
);

WeakHandle<game.data.RangedAttackPackage_Record> GetCurrentRangedAttack() RTTI

bool HasScope() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "HasScope",
    (Object_HasScope x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasScope(
    game.weapon.Object self
);

Vector4 GetScopeOffset() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetScopeOffset",
    (Object_GetScopeOffset x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetScopeOffset(
    game.weapon.Object self
);

Vector4 GetIronSightOffset() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetIronSightOffset",
    (Object_GetIronSightOffset x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetIronSightOffset(
    game.weapon.Object self
);

Vector4 GetMuzzleOffset() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetMuzzleOffset",
    (Object_GetMuzzleOffset x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetMuzzleOffset(
    game.weapon.Object self
);

bool IsSilenced() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "IsSilenced",
    (Object_IsSilenced x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsSilenced(
    game.weapon.Object self
);

bool IsVehiclePowerWeaponRear(game.Object vehicle) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "IsVehiclePowerWeaponRear",
    (Object_IsVehiclePowerWeaponRear x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsVehiclePowerWeaponRear(
    game.weapon.Object self,
    game.Object? vehicle
);

bool IsTargetLocked() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "IsTargetLocked",
    (Object_IsTargetLocked x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsTargetLocked(
    game.weapon.Object self
);

bool UpdateTargetingSight(ent.EntityID targetID, Vector4 targetPosition) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "UpdateTargetingSight",
    (Object_UpdateTargetingSight x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_UpdateTargetingSight(
    game.weapon.Object self,
    ent.EntityID targetID,
    Vector4 targetPosition
);

void ShootStraight(bool shootStraight) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "ShootStraight",
    (Object_ShootStraight x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ShootStraight(
    game.weapon.Object self,
    bool shootStraight
);

void SetupBurstFireSound(int numShotsInBurst) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "SetupBurstFireSound",
    (Object_SetupBurstFireSound x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SetupBurstFireSound(
    game.weapon.Object self,
    int numShotsInBurst
);

void SetWeaponEffects(WeakHandle<game.data.WeaponVFXAction_Record>[] weaponVFXActionRecord) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "SetWeaponEffects",
    (Object_SetWeaponEffects x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SetWeaponEffects(
    game.weapon.Object self,
    WeakHandle<game.data.WeaponVFXAction_Record>[] weaponVFXActionRecord
);

void RemoveWeaponEffects() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "RemoveWeaponEffects",
    (Object_RemoveWeaponEffects x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_RemoveWeaponEffects(
    game.weapon.Object self
);

Transform GetMuzzleSlotWorldTransform() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetMuzzleSlotWorldTransform",
    (Object_GetMuzzleSlotWorldTransform x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Transform>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetMuzzleSlotWorldTransform(
    game.weapon.Object self
);

bool IsControlledByPlayer() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "IsControlledByPlayer",
    (Object_IsControlledByPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsControlledByPlayer(
    game.weapon.Object self
);

void SetVisible(bool visible) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "SetVisible",
    (Object_SetVisible x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SetVisible(
    game.weapon.Object self,
    bool visible
);

void PlayMeleeSound() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "PlayMeleeSound;",
    (Object_PlayMeleeSound x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_PlayMeleeSound(
    game.weapon.Object self
);

void StopMeleeSound() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "StopMeleeSound;",
    (Object_StopMeleeSound x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_StopMeleeSound(
    game.weapon.Object self
);

bool OnGameAttached() overrideRTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "OnGameAttached",
    (Object_OnGameAttached x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnGameAttached(
    game.weapon.Object self
);

void SetupWeaponEffects() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "SetupWeaponEffects;",
    (Object_SetupWeaponEffects x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SetupWeaponEffects(
    game.weapon.Object self
);

bool OnVisualSpawnAttached() overrideRTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "OnVisualSpawnAttached",
    (Object_OnVisualSpawnAttached x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnVisualSpawnAttached(
    game.weapon.Object self
);

bool OnPlayerWeaponSetupEvent(PlayerWeaponSetupEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "OnPlayerWeaponSetupEvent",
    (Object_OnPlayerWeaponSetupEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnPlayerWeaponSetupEvent(
    game.weapon.Object self,
    PlayerWeaponSetupEvent? evt
);

bool OnDetach() overrideRTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "OnDetach",
    (Object_OnDetach x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnDetach(
    game.weapon.Object self
);

bool HasSecondaryTriggerMode() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "HasSecondaryTriggerMode;",
    (Object_HasSecondaryTriggerMode x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasSecondaryTriggerMode(
    game.weapon.Object self
);

game.data.WeaponItem_Record? GetWeaponRecord() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetWeaponRecord;",
    (Object_GetWeaponRecord x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.WeaponItem_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetWeaponRecord(
    game.weapon.Object self
);

bool IsHeavyWeapon() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "IsHeavyWeapon;",
    (Object_IsHeavyWeapon x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsHeavyWeapon(
    game.weapon.Object self
);

bool IsRanged() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "IsRanged;",
    (Object_IsRanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsRanged(
    game.weapon.Object self
);

bool IsMelee() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "IsMelee;",
    (Object_IsMelee x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsMelee(
    game.weapon.Object self
);

bool IsShotgun() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "IsShotgun;",
    (Object_IsShotgun x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsShotgun(
    game.weapon.Object self
);

bool IsBlade() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "IsBlade;",
    (Object_IsBlade x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsBlade(
    game.weapon.Object self
);

bool IsBlunt() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "IsBlunt;",
    (Object_IsBlunt x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsBlunt(
    game.weapon.Object self
);

bool IsMonowire() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "IsMonowire;",
    (Object_IsMonowire x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsMonowire(
    game.weapon.Object self
);

bool IsMantisBlades() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "IsMantisBlades;",
    (Object_IsMantisBlades x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsMantisBlades(
    game.weapon.Object self
);

bool IsThrowable() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "IsThrowable;",
    (Object_IsThrowable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsThrowable(
    game.weapon.Object self
);

bool IsCharged() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "IsCharged;",
    (Object_IsCharged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsCharged(
    game.weapon.Object self
);

void SetCharged(bool charged) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "SetCharged;Bool",
    (Object_SetCharged x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SetCharged(
    game.weapon.Object self,
    bool charged
);

bool WeaponHasTag(CName tag) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "WeaponHasTag;CName",
    (Object_WeaponHasTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_WeaponHasTag(
    game.weapon.Object self,
    CName tag
);

game.IBlackboard? GetAIBlackboard() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetAIBlackboard;",
    (Object_GetAIBlackboard x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IBlackboard>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetAIBlackboard(
    game.weapon.Object self
);

CName GetTriggerEffectName() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetTriggerEffectName;",
    (Object_GetTriggerEffectName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetTriggerEffectName(
    game.weapon.Object self
);

CName GetCurrentMeleeTrailEffectName() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetCurrentMeleeTrailEffectName;",
    (Object_GetCurrentMeleeTrailEffectName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetCurrentMeleeTrailEffectName(
    game.weapon.Object self
);

void SetMaxChargeThreshold(float maxCharge) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "SetMaxChargeThreshold;Float",
    (Object_SetMaxChargeThreshold x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SetMaxChargeThreshold(
    game.weapon.Object self,
    float maxCharge
);

float GetMaxChargeTreshold() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetMaxChargeTreshold;",
    (Object_GetMaxChargeTreshold x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetMaxChargeTreshold(
    game.weapon.Object self
);

bool IsMagazineEmpty() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "IsMagazineEmpty;",
    (Object_IsMagazineEmpty x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsMagazineEmpty(
    game.weapon.Object self
);

void CatcheTriggerEffectFromWeaponType() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "CatcheTriggerEffectFromWeaponType;",
    (Object_CatcheTriggerEffectFromWeaponType x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_CatcheTriggerEffectFromWeaponType(
    game.weapon.Object self
);

void SendScopeData() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "SendScopeData;",
    (Object_SendScopeData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SendScopeData(
    game.weapon.Object self
);

void SendWeaponStatsAnimFeature() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "SendWeaponStatsAnimFeature;",
    (Object_SendWeaponStatsAnimFeature x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SendWeaponStatsAnimFeature(
    game.weapon.Object self
);

void OnUpdateWeaponStatsEvent(UpdateWeaponStatsEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "OnUpdateWeaponStatsEvent;UpdateWeaponStatsEvent",
    (Object_OnUpdateWeaponStatsEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnUpdateWeaponStatsEvent(
    game.weapon.Object self,
    UpdateWeaponStatsEvent? evt
);

void SendWeaponOwnerVehicleData() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "SendWeaponOwnerVehicleData;",
    (Object_SendWeaponOwnerVehicleData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SendWeaponOwnerVehicleData(
    game.weapon.Object self
);

bool HasMonowireWithQuickhackSelected() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "HasMonowireWithQuickhackSelected;",
    (Object_HasMonowireWithQuickhackSelected x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasMonowireWithQuickhackSelected(
    game.weapon.Object self
);

CName GetAppearanceNameFromComponent(CName componentName) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetAppearanceNameFromComponent;CName",
    (Object_GetAppearanceNameFromComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetAppearanceNameFromComponent(
    game.weapon.Object self,
    CName componentName
);

CName GetNamePropertyFromWeaponDefinition(TDBID property) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetNamePropertyFromWeaponDefinition;TweakDBID",
    (Object_GetNamePropertyFromWeaponDefinition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetNamePropertyFromWeaponDefinition(
    game.weapon.Object self,
    TDBID property
);

bool GetBoolPropertyFromWeaponDefinition(TDBID property) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetBoolPropertyFromWeaponDefinition;TweakDBID",
    (Object_GetBoolPropertyFromWeaponDefinition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetBoolPropertyFromWeaponDefinition(
    game.weapon.Object self,
    TDBID property
);

int GetNextWeaponOwner() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetNextWeaponOwner;",
    (Object_GetNextWeaponOwner x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetNextWeaponOwner(
    game.weapon.Object self
);

void SetWeaponOwner(int owner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "SetWeaponOwner;Int32",
    (Object_SetWeaponOwner x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SetWeaponOwner(
    game.weapon.Object self,
    int owner
);

void SetWeaponOwner() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "SetWeaponOwner;",
    (Object_SetWeaponOwner2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SetWeaponOwner2(
    game.weapon.Object self
);

bool OnSetWeaponOwner(SetWeaponOwnerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "OnSetWeaponOwner",
    (Object_OnSetWeaponOwner x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnSetWeaponOwner(
    game.weapon.Object self,
    SetWeaponOwnerEvent? evt
);

void CheckLocked() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "CheckLocked;",
    (Object_CheckLocked x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_CheckLocked(
    game.weapon.Object self
);

bool OnWaponeventsOwnerAimEvent(game.weapon.events.OwnerAimEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "OnWaponeventsOwnerAimEvent",
    (Object_OnWaponeventsOwnerAimEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnWaponeventsOwnerAimEvent(
    game.weapon.Object self,
    game.weapon.events.OwnerAimEvent? evt
);

bool OnOutlineRequestEvent(OutlineRequestEvent evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "OnOutlineRequestEvent",
    (Object_OnOutlineRequestEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnOutlineRequestEvent(
    game.weapon.Object self,
    OutlineRequestEvent? evt
);

bool OnForceFadeOutlineEventForWeapon(ForceFadeOutlineEventForWeapon evt) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "OnForceFadeOutlineEventForWeapon",
    (Object_OnForceFadeOutlineEventForWeapon x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnForceFadeOutlineEventForWeapon(
    game.weapon.Object self,
    ForceFadeOutlineEventForWeapon? evt
);

void HandleVisualEffectsSetup() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "HandleVisualEffectsSetup;",
    (Object_HandleVisualEffectsSetup x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HandleVisualEffectsSetup(
    game.weapon.Object self
);

game.data.DamageType GetCurrentDamageType() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetCurrentDamageType;",
    (Object_GetCurrentDamageType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.DamageType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetCurrentDamageType(
    game.weapon.Object self
);

void SetCurrentMeleeTrailEffect(game.data.DamageType damageType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "SetCurrentMeleeTrailEffect;gamedataDamageType",
    (Object_SetCurrentMeleeTrailEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SetCurrentMeleeTrailEffect(
    game.weapon.Object self,
    game.data.DamageType damageType
);

bool OnUpdateMeleeTrailEffect(UpdateMeleeTrailEffectEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "OnUpdateMeleeTrailEffect",
    (Object_OnUpdateMeleeTrailEffect x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnUpdateMeleeTrailEffect(
    game.weapon.Object self,
    UpdateMeleeTrailEffectEvent? evt
);

void StartIdleMeleeEffect(game.data.DamageType damageType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "StartIdleMeleeEffect;gamedataDamageType",
    (Object_StartIdleMeleeEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_StartIdleMeleeEffect(
    game.weapon.Object self,
    game.data.DamageType damageType
);

void StartCurrentMeleeTrailEffect(string? attackSide) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "StartCurrentMeleeTrailEffect;String",
    (Object_StartCurrentMeleeTrailEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_StartCurrentMeleeTrailEffect(
    game.weapon.Object self,
    string? attackSide
);

void StopCurrentMeleeTrailEffect(string? attackSide) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "StopCurrentMeleeTrailEffect;String",
    (Object_StopCurrentMeleeTrailEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_StopCurrentMeleeTrailEffect(
    game.weapon.Object self,
    string? attackSide
);

void OnAttachSetStatPools() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "OnAttachSetStatPools;",
    (Object_OnAttachSetStatPools x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnAttachSetStatPools(
    game.weapon.Object self
);

void RegisterStatPoolListeners() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "RegisterStatPoolListeners;",
    (Object_RegisterStatPoolListeners x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_RegisterStatPoolListeners(
    game.weapon.Object self
);

bool OnWeaponRegisterChargeStatListener(WeaponRegisterChargeStatListener evt) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "OnWeaponRegisterChargeStatListener",
    (Object_OnWeaponRegisterChargeStatListener x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnWeaponRegisterChargeStatListener(
    game.weapon.Object self,
    WeaponRegisterChargeStatListener? evt
);

void RegisterChargeStatListener() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "RegisterChargeStatListener;",
    (Object_RegisterChargeStatListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_RegisterChargeStatListener(
    game.weapon.Object self
);

void UnregisterChargeStatListener() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "UnregisterChargeStatListener;",
    (Object_UnregisterChargeStatListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_UnregisterChargeStatListener(
    game.weapon.Object self
);

void RegisterStatListeners() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "RegisterStatListeners;",
    (Object_RegisterStatListeners x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_RegisterStatListeners(
    game.weapon.Object self
);

bool OnUpdateOverheat(UpdateOverheatEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "OnUpdateOverheat",
    (Object_OnUpdateOverheat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnUpdateOverheat(
    game.weapon.Object self,
    UpdateOverheatEvent? evt
);

void StartOverheatEffect() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "StartOverheatEffect;",
    (Object_StartOverheatEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_StartOverheatEffect(
    game.weapon.Object self
);

bool OnSetActiveWeapon(game.weapon.events.SetActiveWeaponEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "OnSetActiveWeapon",
    (Object_OnSetActiveWeapon x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnSetActiveWeapon(
    game.weapon.Object self,
    game.weapon.events.SetActiveWeaponEvent? evt
);

bool OnRemoveActiveWeapon(game.weapon.events.RemoveActiveWeaponEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "OnRemoveActiveWeapon",
    (Object_OnRemoveActiveWeapon x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnRemoveActiveWeapon(
    game.weapon.Object self,
    game.weapon.events.RemoveActiveWeaponEvent? evt
);

int GetBlackboardIntVariable(game.bb.ScriptID_Int32 id) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetBlackboardIntVariable;BlackboardID_Int",
    (Object_GetBlackboardIntVariable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetBlackboardIntVariable(
    game.weapon.Object self,
    game.bb.ScriptID_Int32 id
);

bool OnUpdateWeaponCharge(UpdateWeaponChargeEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "OnUpdateWeaponCharge",
    (Object_OnUpdateWeaponCharge x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnUpdateWeaponCharge(
    game.weapon.Object self,
    UpdateWeaponChargeEvent? evt
);

void PlayMeleeSound(game.Object self, CName soundName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "PlayMeleeSound;GameObjectCName",
    (Object_PlayMeleeSound2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_PlayMeleeSound2(
    game.weapon.Object self,
    game.Object? self,
    CName soundName
);

void StopMeleeSound(game.Object self, CName soundName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "StopMeleeSound;GameObjectCName",
    (Object_StopMeleeSound2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_StopMeleeSound2(
    game.weapon.Object self,
    game.Object? self,
    CName soundName
);

float GetPerfectChargeWindow() RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "GetPerfectChargeWindow;",
    (Object_GetPerfectChargeWindow x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetPerfectChargeWindow(
    game.weapon.Object self
);

void PlayPerfectChargeEvent(game.Object self, CName type) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "PlayPerfectChargeEvent;GameObjectCName",
    (Object_PlayPerfectChargeEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_PlayPerfectChargeEvent(
    game.weapon.Object self,
    game.Object? self,
    CName type
);

void PlayPerfectChargeUIEvent(CName type) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "PlayPerfectChargeUIEvent;CName",
    (Object_PlayPerfectChargeUIEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_PlayPerfectChargeUIEvent(
    game.weapon.Object self,
    CName type
);

bool OnStartOverheatEffectEvent(StartOverheatEffectEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "OnStartOverheatEffectEvent",
    (Object_OnStartOverheatEffectEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnStartOverheatEffectEvent(
    game.weapon.Object self,
    StartOverheatEffectEvent? evt
);

bool OnUpdateDamageChangeEvent(UpdateDamageChangeEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "OnUpdateDamageChangeEvent",
    (Object_OnUpdateDamageChangeEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnUpdateDamageChangeEvent(
    game.weapon.Object self,
    UpdateDamageChangeEvent? evt
);

bool OnMeleeHitEvent(MeleeHitEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "OnMeleeHitEvent",
    (Object_OnMeleeHitEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnMeleeHitEvent(
    game.weapon.Object self,
    MeleeHitEvent? evt
);

bool OnAmmoStateChangeEvent(AmmoStateChangeEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "OnAmmoStateChangeEvent",
    (Object_OnAmmoStateChangeEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_OnAmmoStateChangeEvent(
    game.weapon.Object self,
    AmmoStateChangeEvent? evt
);

static void TriggerWeaponEffects(WeakHandle<game.weapon.Object> weapon, game.data.FxAction fxAction, world.EffectBlackboard? fxBlackboard)

staticRTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "TriggerWeaponEffects",
    (Object_TriggerWeaponEffects x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_TriggerWeaponEffects(
    WeakHandle<game.weapon.Object> weapon,
    game.data.FxAction fxAction,
    world.EffectBlackboard? fxBlackboard
);

static float GetWeaponCharge(WeakHandle<game.weapon.Object> weapon) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::GetWeaponCharge;WeaponObject",
    (Object_GetWeaponCharge x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

static float TechPierceChargeLevel(game.weapon.Object self) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::TechPierceChargeLevel;WeaponObject",
    (Object_TechPierceChargeLevel x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_TechPierceChargeLevel(
    game.weapon.Object? self
);

static bool IsOfType(game.ItemID weaponID, game.data.ItemType type) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::IsOfType;ItemIDgamedataItemType",
    (Object_IsOfType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsOfType(
    game.ItemID weaponID,
    game.data.ItemType type
);

static game.data.ItemType GetWeaponType(game.ItemID weaponID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::GetWeaponType;ItemID",
    (Object_GetWeaponType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.GameDataItemType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetWeaponType(
    game.ItemID weaponID
);

static game.ItemID GetAmmoType(game.ItemID weaponID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::GetAmmoType;ItemID",
    (Object_GetAmmoType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetAmmoType(
    game.ItemID weaponID
);

static uint GetMagazineAmmoCount(game.weapon.Object self) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::GetMagazineAmmoCount;WeaponObject",
    (Object_GetMagazineAmmoCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetMagazineAmmoCount(
    game.weapon.Object? self
);

static void SendMuzzleOffset(game.weapon.Object weapon, game.Object owner) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "gameweaponObject::SendMuzzleOffset;WeaponObjectGameObject",
    (Object_SendMuzzleOffset x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_SendMuzzleOffset(
    game.weapon.Object? weapon,
    game.Object? owner
);

static bool IsBlade(game.ItemID weaponID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::IsBlade;ItemID",
    (Object_IsBlade2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsBlade2(
    game.ItemID weaponID
);

static float GetFullyChargedThreshold(game.weapon.Object self) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::GetFullyChargedThreshold;WeaponObject",
    (Object_GetFullyChargedThreshold x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetFullyChargedThreshold(
    game.weapon.Object? self
);

static CName GetRangedWeaponTag() staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::GetRangedWeaponTag;",
    (Object_GetRangedWeaponTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetRangedWeaponTag();

static bool IsRanged(WeakHandle<game.data.Item_Record> wpnRec) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::IsRanged;Item_Record",
    (Object_IsRanged2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsRanged2(
    WeakHandle<game.data.Item_Record> wpnRec
);

static game.ItemID GetAmmoType(WeakHandle<game.weapon.Object> weapon) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::GetAmmoType;WeaponObject",
    (Object_GetAmmoType2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

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

static void KillFXActionFromSet(WeakHandle<game.weapon.Object> weapon, WeakHandle<game.data.WeaponVFXSet_Record> weaponFxSet, game.data.FxAction fxAction, world.EffectBlackboard fxBlackboard)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "gameweaponObject::KillFXActionFromSet;WeaponObjectWeaponVFXSet_RecordgamedataFxActionworldEffectBlackboard",
    (Object_KillFXActionFromSet x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_KillFXActionFromSet(
    WeakHandle<game.weapon.Object> weapon,
    WeakHandle<game.data.WeaponVFXSet_Record> weaponFxSet,
    game.data.FxAction fxAction,
    world.EffectBlackboard? fxBlackboard
);

static float CanIgnoreArmor(game.weapon.Object self) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::CanIgnoreArmor;WeaponObject",
    (Object_CanIgnoreArmor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_CanIgnoreArmor(
    game.weapon.Object? self
);

static CName GetDriverCombatRangedWeaponTag() staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::GetDriverCombatRangedWeaponTag;",
    (Object_GetDriverCombatRangedWeaponTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetDriverCombatRangedWeaponTag();

static CName GetShotgunWeaponTag() staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::GetShotgunWeaponTag;",
    (Object_GetShotgunWeaponTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetShotgunWeaponTag();

static void StopWeaponEffects(WeakHandle<game.Object> weaponOwner, WeakHandle<game.weapon.Object> weapon, game.data.FxAction fxAction, world.EffectBlackboard fxBlackboard)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "gameweaponObject::StopWeaponEffects;GameObjectWeaponObjectgamedataFxActionworldEffectBlackboard",
    (Object_StopWeaponEffects x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_StopWeaponEffects(
    WeakHandle<game.Object> weaponOwner,
    WeakHandle<game.weapon.Object> weapon,
    game.data.FxAction fxAction,
    world.EffectBlackboard? fxBlackboard
);

static bool IsMelee(game.ItemID weaponID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::IsMelee;ItemID",
    (Object_IsMelee2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsMelee2(
    game.ItemID weaponID
);

static bool IsRanged(game.ItemID weaponID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::IsRanged;ItemID",
    (Object_IsRanged3 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsRanged3(
    game.ItemID weaponID
);

static float GetWeaponChargeNormalized(WeakHandle<game.weapon.Object> weapon) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::GetWeaponChargeNormalized;WeaponObject",
    (Object_GetWeaponChargeNormalized x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

static bool IsBlunt(game.ItemID weaponID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::IsBlunt;ItemID",
    (Object_IsBlunt2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsBlunt2(
    game.ItemID weaponID
);

static void SendAmmoUpdateEvent(WeakHandle<game.Object> weaponOwner, WeakHandle<game.weapon.Object> weapon) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "gameweaponObject::SendAmmoUpdateEvent;GameObjectWeaponObject",
    (Object_SendAmmoUpdateEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static void RegisterChargeStatListener(WeakHandle<game.weapon.Object> weapon, bool register) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "gameweaponObject::RegisterChargeStatListener;WeaponObjectBool",
    (Object_RegisterChargeStatListener2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_RegisterChargeStatListener2(
    WeakHandle<game.weapon.Object> weapon,
    bool register
);

static float GetBaseMaxChargeThreshold(game.weapon.Object self) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::GetBaseMaxChargeThreshold;WeaponObject",
    (Object_GetBaseMaxChargeThreshold x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetBaseMaxChargeThreshold(
    game.weapon.Object? self
);

static bool IsOneHandedRanged(game.ItemID weaponID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::IsOneHandedRanged;ItemID",
    (Object_IsOneHandedRanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsOneHandedRanged(
    game.ItemID weaponID
);

static bool IsMagazineEmpty(game.weapon.Object self) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::IsMagazineEmpty;WeaponObject",
    (Object_IsMagazineEmpty2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsMagazineEmpty2(
    game.weapon.Object? self
);

static void ChangeTriggerMode(game.weapon.Object self, game.data.TriggerMode triggerMode) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameweaponObject",
    "gameweaponObject::ChangeTriggerMode;WeaponObjectgamedataTriggerMode",
    (Object_ChangeTriggerMode x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_ChangeTriggerMode(
    game.weapon.Object? self,
    game.data.TriggerMode triggerMode
);

static CName GetMeleeWeaponTag() staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::GetMeleeWeaponTag;",
    (Object_GetMeleeWeaponTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetMeleeWeaponTag();

static bool IsMagazineFull(game.weapon.Object self) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::IsMagazineFull;WeaponObject",
    (Object_IsMagazineFull x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsMagazineFull(
    game.weapon.Object? self
);

static bool HasAvailableAmmo(game.weapon.Object self) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::HasAvailableAmmo;WeaponObject",
    (Object_HasAvailableAmmo x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasAvailableAmmo(
    game.weapon.Object? self
);

static bool CanReload(game.weapon.Object self) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::CanReload;WeaponObject",
    (Object_CanReload x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_CanReload(
    game.weapon.Object? self
);

static bool IsMelee(WeakHandle<game.data.WeaponItem_Record> wpnRec) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::IsMelee;WeaponItem_Record",
    (Object_IsMelee3 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsMelee3(
    WeakHandle<game.data.WeaponItem_Record> wpnRec
);

static float GetOverchargeThreshold(game.weapon.Object self) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::GetOverchargeThreshold;WeaponObject",
    (Object_GetOverchargeThreshold x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetOverchargeThreshold(
    game.weapon.Object? self
);

static bool IsFists(game.ItemID weaponID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::IsFists;ItemID",
    (Object_IsFists x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsFists(
    game.ItemID weaponID
);

static bool IsCyberwareWeapon(game.ItemID weaponID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::IsCyberwareWeapon;ItemID",
    (Object_IsCyberwareWeapon x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_IsCyberwareWeapon(
    game.ItemID weaponID
);

static bool HasAvailableAmmoInInventory(game.weapon.Object self) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::HasAvailableAmmoInInventory;WeaponObject",
    (Object_HasAvailableAmmoInInventory x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_HasAvailableAmmoInInventory(
    game.weapon.Object? self
);

static CName GetOneHandedRangedWeaponTag() staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::GetOneHandedRangedWeaponTag;",
    (Object_GetOneHandedRangedWeaponTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetOneHandedRangedWeaponTag();

static float GetMagazinePercentage(game.weapon.Object self) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::GetMagazinePercentage;WeaponObject",
    (Object_GetMagazinePercentage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetMagazinePercentage(
    game.weapon.Object? self
);

static CName GetDriverCombatBikeWeaponTag() staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::GetDriverCombatBikeWeaponTag;",
    (Object_GetDriverCombatBikeWeaponTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetDriverCombatBikeWeaponTag();

static bool CanCriticallyHit(game.weapon.Object self) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::CanCriticallyHit;WeaponObject",
    (Object_CanCriticallyHit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_CanCriticallyHit(
    game.weapon.Object? self
);

static uint GetMagazineCapacity(game.weapon.Object self) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameweaponObject",
    "gameweaponObject::GetMagazineCapacity;WeaponObject",
    (Object_GetMagazineCapacity x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Object_GetMagazineCapacity(
    game.weapon.Object? self
);