class game

DamageSystem

game.DamageSystem

3 properties
110 functions

Extends game.IDamageSystem game.IReplicatedGameSystem game.IGameSystem IScriptable ISerializable

Properties

Property	Type	Offset
`previewTarget`	`preview.TargetStruct`	`0x0`	scripted
`previewLock`	`bool`	`0x18`	scripted
`previewRWLockTemp`	`ScriptReentrantRWLock`	`0x20`	scripted

Functions

void ProcessSyncStageCallbacks(game.DamagePipelineStage stage, game.events.HitEvent hitEvent, game.DamageListenerPipelineType damagePipelineType)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessSyncStageCallbacks",
    (DamageSystem_ProcessSyncStageCallbacks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessSyncStageCallbacks(
    game.DamageSystem self,
    game.DamagePipelineStage stage,
    game.events.HitEvent? hitEvent,
    game.DamageListenerPipelineType damagePipelineType
);

void ProcessSyncStageMissCallbacks(game.events.MissEvent missEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessSyncStageMissCallbacks",
    (DamageSystem_ProcessSyncStageMissCallbacks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessSyncStageMissCallbacks(
    game.DamageSystem self,
    game.events.MissEvent? missEvent
);

void QueueHitEvent(game.events.HitEvent evt, WeakHandle<game.Object> receiver) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "QueueHitEvent",
    (DamageSystem_QueueHitEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_QueueHitEvent(
    game.DamageSystem self,
    game.events.HitEvent? evt,
    WeakHandle<game.Object> receiver
);

void QueueMissEvent(game.events.MissEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "QueueMissEvent",
    (DamageSystem_QueueMissEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_QueueMissEvent(
    game.DamageSystem self,
    game.events.MissEvent? evt
);

void RegisterListener(game.ScriptedDamageSystemListener damageListener, ent.EntityID registereeID, game.DamageCallbackType callbackType, game.DamageListenerPipelineType? damagePipelineType)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "RegisterListener",
    (DamageSystem_RegisterListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_RegisterListener(
    game.DamageSystem self,
    game.ScriptedDamageSystemListener? damageListener,
    ent.EntityID registereeID,
    game.DamageCallbackType callbackType,
    game.DamageListenerPipelineType? damagePipelineType
);

void RegisterSyncListener(game.ScriptedDamageSystemListener damageListener, ent.EntityID registereeID, game.DamageCallbackType callbackType, game.DamagePipelineStage stage, game.DamageListenerPipelineType? damagePipelineType)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "RegisterSyncListener",
    (DamageSystem_RegisterSyncListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_RegisterSyncListener(
    game.DamageSystem self,
    game.ScriptedDamageSystemListener? damageListener,
    ent.EntityID registereeID,
    game.DamageCallbackType callbackType,
    game.DamagePipelineStage stage,
    game.DamageListenerPipelineType? damagePipelineType
);

void StartProjectionPipeline(game.events.ProjectedHitEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "StartProjectionPipeline",
    (DamageSystem_StartProjectionPipeline x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_StartProjectionPipeline(
    game.DamageSystem self,
    game.events.ProjectedHitEvent? evt
);

void UnregisterListener(game.ScriptedDamageSystemListener damageListener, ent.EntityID registereeID, game.DamageCallbackType callbackType, game.DamageListenerPipelineType? damagePipelineType)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "UnregisterListener",
    (DamageSystem_UnregisterListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_UnregisterListener(
    game.DamageSystem self,
    game.ScriptedDamageSystemListener? damageListener,
    ent.EntityID registereeID,
    game.DamageCallbackType callbackType,
    game.DamageListenerPipelineType? damagePipelineType
);

void UnregisterSyncListener(game.ScriptedDamageSystemListener damageListener, ent.EntityID registereeID, game.DamageCallbackType callbackType, game.DamagePipelineStage stage, game.DamageListenerPipelineType? damagePipelineType)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "UnregisterSyncListener",
    (DamageSystem_UnregisterSyncListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_UnregisterSyncListener(
    game.DamageSystem self,
    game.ScriptedDamageSystemListener? damageListener,
    ent.EntityID registereeID,
    game.DamageCallbackType callbackType,
    game.DamagePipelineStage stage,
    game.DamageListenerPipelineType? damagePipelineType
);

void ProcessPipeline(game.events.HitEvent hitEvent, game.damage.CacheData cache) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessPipeline;gameHitEventCacheData",
    (DamageSystem_ProcessPipeline x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessPipeline(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent,
    game.damage.CacheData? cache
);

void ProcessMissPipeline(game.events.MissEvent missEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessMissPipeline;gameMissEvent",
    (DamageSystem_ProcessMissPipeline x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessMissPipeline(
    game.DamageSystem self,
    game.events.MissEvent? missEvent
);

void ProcessProjectionPipeline(game.events.ProjectedHitEvent hitEvent, game.damage.CacheData cache) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessProjectionPipeline;gameProjectedHitEventCacheData",
    (DamageSystem_ProcessProjectionPipeline x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessProjectionPipeline(
    game.DamageSystem self,
    game.events.ProjectedHitEvent? hitEvent,
    game.damage.CacheData? cache
);

bool CheckProjectionPipelineTargetConditions(game.events.ProjectedHitEvent hitEvent) RTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "CheckProjectionPipelineTargetConditions;gameProjectedHitEvent",
    (DamageSystem_CheckProjectionPipelineTargetConditions x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_CheckProjectionPipelineTargetConditions(
    game.DamageSystem self,
    game.events.ProjectedHitEvent? hitEvent
);

void SetPreviewTargetStruct(WeakHandle<game.Object> trackedTarget, EHitReactionZone bodyPart, bool hittingBreach) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "SetPreviewTargetStruct;GameObjectEHitReactionZoneBool",
    (DamageSystem_SetPreviewTargetStruct x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_SetPreviewTargetStruct(
    game.DamageSystem self,
    WeakHandle<game.Object> trackedTarget,
    EHitReactionZone bodyPart,
    bool hittingBreach
);

void ClearPreviewTargetStruct() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ClearPreviewTargetStruct;",
    (DamageSystem_ClearPreviewTargetStruct x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ClearPreviewTargetStruct(
    game.DamageSystem self
);

void SetPreviewLock(bool newState) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "SetPreviewLock;Bool",
    (DamageSystem_SetPreviewLock x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_SetPreviewLock(
    game.DamageSystem self,
    bool newState
);

EHitReactionZone GetHitReactionZone(game.events.ProjectedHitEvent hitEvent) RTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "GetHitReactionZone;gameProjectedHitEvent",
    (DamageSystem_GetHitReactionZone x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EHitReactionZone>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_GetHitReactionZone(
    game.DamageSystem self,
    game.events.ProjectedHitEvent? hitEvent
);

CName CreateDebugDataName(WeakHandle<game.Object> gameObject) RTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "CreateDebugDataName;GameObject",
    (DamageSystem_CreateDebugDataName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_CreateDebugDataName(
    game.DamageSystem self,
    WeakHandle<game.Object> gameObject
);

void GatherDebugData(game.events.HitEvent hitEvent, game.damage.CacheData cache, out game.damage.HitDebugData hitDebugData)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "GatherDebugData;gameHitEventCacheDataHitDebugData",
    (DamageSystem_GatherDebugData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_GatherDebugData(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent,
    game.damage.CacheData? cache,
    game.damage.HitDebugData? hitDebugData
);

void FillInDamageBlackboard(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "FillInDamageBlackboard;gameHitEvent",
    (DamageSystem_FillInDamageBlackboard x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_FillInDamageBlackboard(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void GatherServerData(game.events.HitEvent hitEvent, game.damage.CacheData cache, out game.damage.ServerHitData serverHitData)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "GatherServerData;gameHitEventCacheDataServerHitData",
    (DamageSystem_GatherServerData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_GatherServerData(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent,
    game.damage.CacheData? cache,
    game.damage.ServerHitData? serverHitData
);

game.ui.DamageInfo[] ConvertHitDataToDamageInfo(game.events.HitEvent hitEvent) RTTI

void ProcessClientHit(game.damage.ServerHitData serverHitData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessClientHit;ServerHitData",
    (DamageSystem_ProcessClientHit x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessClientHit(
    game.DamageSystem self,
    game.damage.ServerHitData? serverHitData
);

void ProcessClientKill(game.damage.ServerKillData serverKillData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessClientKill;ServerKillData",
    (DamageSystem_ProcessClientKill x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessClientKill(
    game.DamageSystem self,
    game.damage.ServerKillData? serverKillData
);

bool PreProcess(game.events.HitEvent hitEvent, game.damage.CacheData cache) RTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "PreProcess;gameHitEventCacheData",
    (DamageSystem_PreProcess x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_PreProcess(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent,
    game.damage.CacheData? cache
);

void ConvertDPSToHitDamage(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ConvertDPSToHitDamage;gameHitEvent",
    (DamageSystem_ConvertDPSToHitDamage x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ConvertDPSToHitDamage(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void CalculateDamageVariants(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "CalculateDamageVariants;gameHitEvent",
    (DamageSystem_CalculateDamageVariants x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_CalculateDamageVariants(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ModifyHitData(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ModifyHitData;gameHitEvent",
    (DamageSystem_ModifyHitData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ModifyHitData(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessDamageReduction(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessDamageReduction;gameHitEvent",
    (DamageSystem_ProcessDamageReduction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessDamageReduction(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessLocalizedDamage(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessLocalizedDamage;gameHitEvent",
    (DamageSystem_ProcessLocalizedDamage x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessLocalizedDamage(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessInstantKill(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessInstantKill;gameHitEvent",
    (DamageSystem_ProcessInstantKill x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessInstantKill(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessDodge(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessDodge;gameHitEvent",
    (DamageSystem_ProcessDodge x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessDodge(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessEvasion(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessEvasion;gameHitEvent",
    (DamageSystem_ProcessEvasion x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessEvasion(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessMitigation(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessMitigation;gameHitEvent",
    (DamageSystem_ProcessMitigation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessMitigation(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessPlayerIncomingDamageMultiplier(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessPlayerIncomingDamageMultiplier;gameHitEvent",
    (DamageSystem_ProcessPlayerIncomingDamageMultiplier x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessPlayerIncomingDamageMultiplier(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void InvulnerabilityCheck(game.events.HitEvent hitEvent, game.damage.CacheData cache) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "InvulnerabilityCheck;gameHitEventCacheData",
    (DamageSystem_InvulnerabilityCheck x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_InvulnerabilityCheck(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent,
    game.damage.CacheData? cache
);

bool DEBUG_InvulnerabilityCheckForVehicle(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "DEBUG_InvulnerabilityCheckForVehicle;gameHitEvent",
    (DamageSystem_DEBUG_InvulnerabilityCheckForVehicle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_DEBUG_InvulnerabilityCheckForVehicle(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ImmortalityCheck(game.events.HitEvent hitEvent, game.damage.CacheData cache) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ImmortalityCheck;gameHitEventCacheData",
    (DamageSystem_ImmortalityCheck x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ImmortalityCheck(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent,
    game.damage.CacheData? cache
);

void DeathCheck(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "DeathCheck;gameHitEvent",
    (DamageSystem_DeathCheck x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_DeathCheck(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void SendVehicleImpactTelemetryIfValid(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "SendVehicleImpactTelemetryIfValid;gameHitEvent",
    (DamageSystem_SendVehicleImpactTelemetryIfValid x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_SendVehicleImpactTelemetryIfValid(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void Process(game.events.HitEvent hitEvent, game.damage.CacheData cache) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "Process;gameHitEventCacheData",
    (DamageSystem_Process x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_Process(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent,
    game.damage.CacheData? cache
);

void ProcessHitReaction(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessHitReaction;gameHitEvent",
    (DamageSystem_ProcessHitReaction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessHitReaction(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessRagdollHit(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessRagdollHit;gameHitEvent",
    (DamageSystem_ProcessRagdollHit x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessRagdollHit(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessCrowdTarget(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessCrowdTarget;gameHitEvent",
    (DamageSystem_ProcessCrowdTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessCrowdTarget(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessTurretAttack(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessTurretAttack;gameHitEvent",
    (DamageSystem_ProcessTurretAttack x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessTurretAttack(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessTurretDamageTakenFromMelee(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessTurretDamageTakenFromMelee;gameHitEvent",
    (DamageSystem_ProcessTurretDamageTakenFromMelee x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessTurretDamageTakenFromMelee(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessDeviceTarget(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessDeviceTarget;gameHitEvent",
    (DamageSystem_ProcessDeviceTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessDeviceTarget(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessOneShotProtection(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessOneShotProtection;gameHitEvent",
    (DamageSystem_ProcessOneShotProtection x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessOneShotProtection(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessPlayerFixedPercentageOverride(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessPlayerFixedPercentageOverride;gameHitEvent",
    (DamageSystem_ProcessPlayerFixedPercentageOverride x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessPlayerFixedPercentageOverride(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessDeviceExplosionDamageToTierNPC(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessDeviceExplosionDamageToTierNPC;gameHitEvent",
    (DamageSystem_ProcessDeviceExplosionDamageToTierNPC x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessDeviceExplosionDamageToTierNPC(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessGrenadeExplosionDamageToPlayer(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessGrenadeExplosionDamageToPlayer;gameHitEvent",
    (DamageSystem_ProcessGrenadeExplosionDamageToPlayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessGrenadeExplosionDamageToPlayer(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessQuickHackModifiers(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessQuickHackModifiers;gameHitEvent",
    (DamageSystem_ProcessQuickHackModifiers x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessQuickHackModifiers(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void PreProcessVehicleTarget(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "PreProcessVehicleTarget;gameHitEvent",
    (DamageSystem_PreProcessVehicleTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_PreProcessVehicleTarget(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessVehicleTarget(game.events.HitEvent hitEvent, game.damage.CacheData cache) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessVehicleTarget;gameHitEventCacheData",
    (DamageSystem_ProcessVehicleTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessVehicleTarget(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent,
    game.damage.CacheData? cache
);

float CalculateVehicleTargetRangedDamage(game.weapon.Object weaponObject, float chargeDamageMultiplier, game.StatsSystem statSystem)

RTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "CalculateVehicleTargetRangedDamage;WeaponObjectFloatStatsSystem",
    (DamageSystem_CalculateVehicleTargetRangedDamage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_CalculateVehicleTargetRangedDamage(
    game.DamageSystem self,
    game.weapon.Object? weaponObject,
    float chargeDamageMultiplier,
    game.StatsSystem? statSystem
);

float CalculateVehicleTargetMeleeDamage(game.weapon.Object weaponObject, game.data.AttackType attackType, bool isBodySlam, game.StatsSystem statSystem)

RTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "CalculateVehicleTargetMeleeDamage;WeaponObjectgamedataAttackTypeBoolStatsSystem",
    (DamageSystem_CalculateVehicleTargetMeleeDamage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_CalculateVehicleTargetMeleeDamage(
    game.DamageSystem self,
    game.weapon.Object? weaponObject,
    game.data.AttackType attackType,
    bool isBodySlam,
    game.StatsSystem? statSystem
);

void ProcessVehicleHit(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessVehicleHit;gameHitEvent",
    (DamageSystem_ProcessVehicleHit x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessVehicleHit(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void DealDamages(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "DealDamages;gameHitEvent",
    (DamageSystem_DealDamages x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_DealDamages(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void SendDamageEvents(game.events.HitEvent hitEvent, SDamageDealt[] resourcesLost) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "SendDamageEvents;gameHitEventscript_ref<array<SDamageDealt>>",
    (DamageSystem_SendDamageEvents x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_SendDamageEvents(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent,
    SDamageDealt[] resourcesLost
);

void PostProcess(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "PostProcess;gameHitEvent",
    (DamageSystem_PostProcess x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_PostProcess(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void SendDamageRequestToPreventionSystem(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "SendDamageRequestToPreventionSystem;gameHitEvent",
    (DamageSystem_SendDamageRequestToPreventionSystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_SendDamageRequestToPreventionSystem(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessStatusEffects(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessStatusEffects;gameHitEvent",
    (DamageSystem_ProcessStatusEffects x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessStatusEffects(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessStatusEffectApplicationStats(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessStatusEffectApplicationStats;gameHitEvent",
    (DamageSystem_ProcessStatusEffectApplicationStats x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessStatusEffectApplicationStats(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ApplyStatusEffectByApplicationRate(game.events.HitEvent hitEvent, game.data.StatType statType, TDBID effect) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ApplyStatusEffectByApplicationRate;gameHitEventgamedataStatTypeTweakDBID",
    (DamageSystem_ApplyStatusEffectByApplicationRate x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ApplyStatusEffectByApplicationRate(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent,
    game.data.StatType statType,
    TDBID effect
);

bool ShouldProcessStatusEffectsOnVehicleDriver(game.events.HitEvent hitEvent, out ent.EntityID driverEntityID) RTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "ShouldProcessStatusEffectsOnVehicleDriver;gameHitEventEntityID",
    (DamageSystem_ShouldProcessStatusEffectsOnVehicleDriver x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ShouldProcessStatusEffectsOnVehicleDriver(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent,
    ent.EntityID driverEntityID
);

bool IsImmune(game.Object target, TDBID statusEffectID, game.damage.AttackData attackData) RTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "IsImmune;GameObjectTweakDBIDAttackData",
    (DamageSystem_IsImmune x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_IsImmune(
    game.DamageSystem self,
    game.Object? target,
    TDBID statusEffectID,
    game.damage.AttackData? attackData
);

void ProcessReturnedDamage(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessReturnedDamage;gameHitEvent",
    (DamageSystem_ProcessReturnedDamage x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessReturnedDamage(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void CalculateGlobalModifiers(game.events.HitEvent hitEvent, game.damage.CacheData cache) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "CalculateGlobalModifiers;gameHitEventCacheData",
    (DamageSystem_CalculateGlobalModifiers x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_CalculateGlobalModifiers(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent,
    game.damage.CacheData? cache
);

void CalculateTargetModifiers(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "CalculateTargetModifiers;gameHitEvent",
    (DamageSystem_CalculateTargetModifiers x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_CalculateTargetModifiers(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void CalculateSourceModifiers(game.events.HitEvent hitEvent, game.damage.CacheData cache) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "CalculateSourceModifiers;gameHitEventCacheData",
    (DamageSystem_CalculateSourceModifiers x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_CalculateSourceModifiers(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent,
    game.damage.CacheData? cache
);

void ProcessPierceAttack(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessPierceAttack;gameHitEvent",
    (DamageSystem_ProcessPierceAttack x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessPierceAttack(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessChargeAttack(game.events.HitEvent hitEvent, game.damage.CacheData cache) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessChargeAttack;gameHitEventCacheData",
    (DamageSystem_ProcessChargeAttack x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessChargeAttack(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent,
    game.damage.CacheData? cache
);

void ProcessRicochet(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessRicochet;gameHitEvent",
    (DamageSystem_ProcessRicochet x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessRicochet(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessSpreadingMultiplier(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessSpreadingMultiplier;gameHitEvent",
    (DamageSystem_ProcessSpreadingMultiplier x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessSpreadingMultiplier(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessStealthAttack(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessStealthAttack;gameHitEvent",
    (DamageSystem_ProcessStealthAttack x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessStealthAttack(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessNPCPassengerVehicleCollision(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessNPCPassengerVehicleCollision;gameHitEvent",
    (DamageSystem_ProcessNPCPassengerVehicleCollision x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessNPCPassengerVehicleCollision(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void CalculateSourceVsTargetModifiers(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "CalculateSourceVsTargetModifiers;gameHitEvent",
    (DamageSystem_CalculateSourceVsTargetModifiers x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_CalculateSourceVsTargetModifiers(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void CacheLocalVars(game.events.HitEvent hitEvent, game.damage.CacheData cache) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "CacheLocalVars;gameHitEventCacheData",
    (DamageSystem_CacheLocalVars x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_CacheLocalVars(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent,
    game.damage.CacheData? cache
);

void ModifyHitFlagsForPlayer(game.events.HitEvent hitEvent, game.damage.CacheData cache) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ModifyHitFlagsForPlayer;gameHitEventCacheData",
    (DamageSystem_ModifyHitFlagsForPlayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ModifyHitFlagsForPlayer(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent,
    game.damage.CacheData? cache
);

bool CheckForQuickExit(game.events.HitEvent hitEvent, game.damage.CacheData cache) RTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "CheckForQuickExit;gameHitEventCacheData",
    (DamageSystem_CheckForQuickExit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_CheckForQuickExit(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent,
    game.damage.CacheData? cache
);

bool IsTargetImmortal(game.damage.CacheData cache) RTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "IsTargetImmortal;CacheData",
    (DamageSystem_IsTargetImmortal x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_IsTargetImmortal(
    game.DamageSystem self,
    game.damage.CacheData? cache
);

bool IsTargetInvulnerable(game.damage.CacheData cache) RTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "IsTargetInvulnerable;CacheData",
    (DamageSystem_IsTargetInvulnerable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_IsTargetInvulnerable(
    game.DamageSystem self,
    game.damage.CacheData? cache
);

bool IsOverridenExplosionVsVehicleHit(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "IsOverridenExplosionVsVehicleHit;gameHitEvent",
    (DamageSystem_IsOverridenExplosionVsVehicleHit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_IsOverridenExplosionVsVehicleHit(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessVehicleVsExplosion(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessVehicleVsExplosion;gameHitEvent",
    (DamageSystem_ProcessVehicleVsExplosion x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessVehicleVsExplosion(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessBikeMelee(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessBikeMelee;gameHitEvent",
    (DamageSystem_ProcessBikeMelee x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessBikeMelee(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessEffectiveRange(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessEffectiveRange;gameHitEvent",
    (DamageSystem_ProcessEffectiveRange x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessEffectiveRange(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessArmor(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessArmor;gameHitEvent",
    (DamageSystem_ProcessArmor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessArmor(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessOnVehicleMitigation(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessOnVehicleMitigation;gameHitEvent",
    (DamageSystem_ProcessOnVehicleMitigation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessOnVehicleMitigation(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

game.data.AttackSubtype GetSubAttackSubType(game.damage.AttackData attackData) RTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "GetSubAttackSubType;AttackData",
    (DamageSystem_GetSubAttackSubType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AttackSubtype>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_GetSubAttackSubType(
    game.DamageSystem self,
    game.damage.AttackData? attackData
);

void ProcessCriticalHit(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessCriticalHit;gameHitEvent",
    (DamageSystem_ProcessCriticalHit x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessCriticalHit(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessDamageMultipliers(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessDamageMultipliers;gameHitEvent",
    (DamageSystem_ProcessDamageMultipliers x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessDamageMultipliers(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessCyberwareModifiers(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessCyberwareModifiers;gameHitEvent",
    (DamageSystem_ProcessCyberwareModifiers x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessCyberwareModifiers(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

float GetArmorPenetrationValue(game.weapon.Object weapon, game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "GetArmorPenetrationValue;WeaponObjectgameHitEvent",
    (DamageSystem_GetArmorPenetrationValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_GetArmorPenetrationValue(
    game.DamageSystem self,
    game.weapon.Object? weapon,
    game.events.HitEvent? hitEvent
);

float GetHeadshotDamageModifier(game.StatsSystem statSystem, game.damage.AttackData attackData) RTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "GetHeadshotDamageModifier;StatsSystemAttackData",
    (DamageSystem_GetHeadshotDamageModifier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_GetHeadshotDamageModifier(
    game.DamageSystem self,
    game.StatsSystem? statSystem,
    game.damage.AttackData? attackData
);

float GetWeakspotDamageModifier(game.StatsSystem statSystem, game.damage.AttackData attackData) RTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "GetWeakspotDamageModifier;StatsSystemAttackData",
    (DamageSystem_GetWeakspotDamageModifier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_GetWeakspotDamageModifier(
    game.DamageSystem self,
    game.StatsSystem? statSystem,
    game.damage.AttackData? attackData
);

float GetCritDamageModifier(game.StatsSystem statSystem, game.damage.AttackData attackData) RTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "GetCritDamageModifier;StatsSystemAttackData",
    (DamageSystem_GetCritDamageModifier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_GetCritDamageModifier(
    game.DamageSystem self,
    game.StatsSystem? statSystem,
    game.damage.AttackData? attackData
);

float GetVehiclePerksDamageMultiplier(game.damage.AttackData attackData) RTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "GetVehiclePerksDamageMultiplier;AttackData",
    (DamageSystem_GetVehiclePerksDamageMultiplier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_GetVehiclePerksDamageMultiplier(
    game.DamageSystem self,
    game.damage.AttackData? attackData
);

bool AllowWeaponCrit(game.damage.AttackData attackData) RTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "AllowWeaponCrit;AttackData",
    (DamageSystem_AllowWeaponCrit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_AllowWeaponCrit(
    game.DamageSystem self,
    game.damage.AttackData? attackData
);

void ProcessBlockAndDeflect(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessBlockAndDeflect;gameHitEvent",
    (DamageSystem_ProcessBlockAndDeflect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessBlockAndDeflect(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessBulletBlockAndDeflect(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessBulletBlockAndDeflect;gameHitEvent",
    (DamageSystem_ProcessBulletBlockAndDeflect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessBulletBlockAndDeflect(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ProcessBulletDeflect(game.events.HitEvent hitEvent, bool isBulletTimeActive, WeakHandle<game.ItemObject> blockingItem)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessBulletDeflect;gameHitEventBoolItemObject",
    (DamageSystem_ProcessBulletDeflect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessBulletDeflect(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent,
    bool isBulletTimeActive,
    WeakHandle<game.ItemObject> blockingItem
);

void ProcessLevelDifference(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ProcessLevelDifference;gameHitEvent",
    (DamageSystem_ProcessLevelDifference x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ProcessLevelDifference(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void ScalePlayerDamage(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "ScalePlayerDamage;gameHitEvent",
    (DamageSystem_ScalePlayerDamage x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_ScalePlayerDamage(
    game.DamageSystem self,
    game.events.HitEvent? hitEvent
);

void SetTutorialFact(CName factName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "SetTutorialFact;CName",
    (DamageSystem_SetTutorialFact x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_SetTutorialFact(
    game.DamageSystem self,
    CName factName
);

void DebugDraw_VehicleHit(ScriptGameInstance gameInstance, Vector4 hitPosition, Vector4 hitDirection, float hitMagnitude)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameDamageSystem",
    "DebugDraw_VehicleHit;GameInstanceVector4Vector4Float",
    (DamageSystem_DebugDraw_VehicleHit x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_DebugDraw_VehicleHit(
    game.DamageSystem self,
    ScriptGameInstance gameInstance,
    Vector4 hitPosition,
    Vector4 hitDirection,
    float hitMagnitude
);

static float GetDamageModFromCurve(CName curve, float value) staticRTTI

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "GetDamageModFromCurve",
    (DamageSystem_GetDamageModFromCurve x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_GetDamageModFromCurve(
    CName curve,
    float value
);

static TDBID GetMantisBladesCripplingRandStatusEffectID() staticRTTI global

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "gameDamageSystem::GetMantisBladesCripplingRandStatusEffectID;",
    (DamageSystem_GetMantisBladesCripplingRandStatusEffectID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

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

static Vector3 GetRandomOffset(Vector3 minOffset, Vector3 maxOffset) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "gameDamageSystem::GetRandomOffset;Vector3Vector3",
    (DamageSystem_GetRandomOffset x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector3>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_GetRandomOffset(
    Vector3 minOffset,
    Vector3 maxOffset
);

static bool HasGrandFinaleStatFlag(game.stateMachine.GameScriptInterface scriptInterface) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "gameDamageSystem::HasGrandFinaleStatFlag;StateGameScriptInterface",
    (DamageSystem_HasGrandFinaleStatFlag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_HasGrandFinaleStatFlag(
    game.stateMachine.GameScriptInterface? scriptInterface
);

static float GetEffectiveRangeModifierForWeapon(game.damage.AttackData attackData, Vector4 hitPosition, game.StatsSystem statsSystem)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameDamageSystem",
    "gameDamageSystem::GetEffectiveRangeModifierForWeapon;AttackDataVector4StatsSystem",
    (DamageSystem_GetEffectiveRangeModifierForWeapon x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DamageSystem_GetEffectiveRangeModifierForWeapon(
    game.damage.AttackData? attackData,
    Vector4 hitPosition,
    game.StatsSystem? statsSystem
);