class

HitReactionComponent

128 properties
163 functions
1 derived class

Extends AIMandatoryComponents AIRelatedComponents game.ScriptableComponent game.Component ent.IComponent IScriptable ISerializable

Derived

HitReactionMechComponent

Properties

Property	Type	Offset
`ownerNPC`	`WeakHandle<NPCPuppet>`	`0x0`	scripted
`ownerPuppet`	`WeakHandle<ScriptedPuppet>`	`0x10`	scripted
`ownerWeapon`	`WeakHandle<game.weapon.Object>`	`0x20`	scripted
`ownerID`	`ent.EntityID`	`0x30`	scripted
`statsSystem`	`game.StatsSystem?`	`0x38`	scripted
`ownerIsMassive`	`bool`	`0x48`	scripted
`impactDamageDuration`	`float`	`0x4C`	scripted
`staggerDamageDuration`	`float`	`0x50`	scripted
`impactDamageDurationMelee`	`float`	`0x54`	scripted
`staggerDamageDurationMelee`	`float`	`0x58`	scripted
`knockdownDamageDuration`	`float`	`0x5C`	scripted
`defeatedMinDuration`	`float`	`0x60`	scripted
`previousHitTime`	`float`	`0x64`	scripted
`reactionType`	`anim.HitReactionType`	`0x68`	scripted
`animHitReaction`	`anim.AnimFeature_HitReactionsData?`	`0x70`	scripted
`lastAnimHitReaction`	`anim.AnimFeature_HitReactionsData?`	`0x80`	scripted
`hitReactionAction`	`ActionHitReactionScriptProxy?`	`0x90`	scripted
`previousAnimHitReactionArray`	`ScriptHitData[]`	`0xA0`	scripted
`lastHitReactionPlayed`	`EAILastHitReactionPlayed`	`0xB0`	scripted
`hitShapeData`	`game.ShapeData`	`0xC0`	scripted
`animVariation`	`int`	`0x130`	scripted
`specificHitTimeout`	`float`	`0x134`	scripted
`quickMeleeCooldown`	`float`	`0x138`	scripted
`dismembermentBodyPartDamageThreshold`	`float[]`	`0x140`	scripted
`woundedBodyPartDamageThreshold`	`float[]`	`0x150`	scripted
`defeatedBodyPartDamageThreshold`	`float[]`	`0x160`	scripted
`defeatedDamageThreshold`	`float`	`0x170`	scripted
`impactDamageThreshold`	`float`	`0x174`	scripted
`staggerDamageThreshold`	`float`	`0x178`	scripted
`knockdownDamageThreshold`	`float`	`0x17C`	scripted
`knockdownImpulseThreshold`	`float`	`0x180`	scripted
`immuneToKnockDown`	`bool`	`0x184`	scripted
`hitComboReset`	`float`	`0x188`	scripted
`physicalImpulseReset`	`float`	`0x18C`	scripted
`guardBreakImpulseReset`	`float`	`0x190`	scripted
`cumulatedDamages`	`float`	`0x194`	scripted
`bodyPartWoundCumulatedDamages`	`float[]`	`0x198`	scripted
`bodyPartDismemberCumulatedDamages`	`float[]`	`0x1A8`	scripted
`attackerWeaponKnockdownImpulse`	`float`	`0x1B8`	scripted
`attackerWeaponKnockdownImpulseForEvade`	`float`	`0x1BC`	scripted
`attackerWeaponKnockdownImpulseForEvadeCumulation`	`float`	`0x1C0`	scripted
`ownerWeaponKnockdownImpulseForEvade`	`float`	`0x1C4`	scripted
`cumulatedPhysicalImpulse`	`float`	`0x1C8`	scripted
`cumulatedGuardBreakImpulse`	`float`	`0x1CC`	scripted
`cumulatedEvadeBreakImpulse`	`float`	`0x1D0`	scripted
`ragdollImpulse`	`float`	`0x1D4`	scripted
`ragdollInfluenceRadius`	`float`	`0x1D8`	scripted
`hitIntensity`	`EAIHitIntensity`	`0x1DC`	scripted
`previousMeleeHitTimeStamp`	`float`	`0x1E0`	scripted
`previousRangedHitTimeStamp`	`float`	`0x1E4`	scripted
`previousBlockTimeStamp`	`float`	`0x1E8`	scripted
`previousParryTimeStamp`	`float`	`0x1EC`	scripted
`previousDodgeTimeStamp`	`float`	`0x1F0`	scripted
`previousRagdollTimeStamp`	`float`	`0x1F4`	scripted
`previousHackStaggerTimeStamp`	`float`	`0x1F8`	scripted
`previousHackImpactTimeStamp`	`float`	`0x1FC`	scripted
`blockCount`	`int`	`0x200`	scripted
`parryCount`	`int`	`0x204`	scripted
`dodgeCount`	`int`	`0x208`	scripted
`hitCount`	`uint`	`0x20C`	scripted
`defeatedHasBeenPlayed`	`bool`	`0x210`	scripted
`defeatedRegisteredTime`	`float`	`0x214`	scripted
`deathHasBeenPlayed`	`bool`	`0x218`	scripted
`deathRegisteredTime`	`float`	`0x21C`	scripted
`extendedDeathRegisteredTime`	`float`	`0x220`	scripted
`extendedDeathDelayRegisteredTime`	`float`	`0x224`	scripted
`extendedHitReactionRegisteredTime`	`float`	`0x228`	scripted
`extendedHitReactionDelayRegisteredTime`	`float`	`0x22C`	scripted
`scatteredGuts`	`bool`	`0x230`	scripted
`cumulativeDamageUpdateInterval`	`float`	`0x234`	scripted
`cumulativeDamageUpdateRequested`	`bool`	`0x238`	scripted
`currentStimId`	`uint`	`0x23C`	scripted
`attackData`	`game.damage.AttackData?`	`0x240`	scripted
`attackDirectionToInt`	`int`	`0x250`	scripted
`hitPosition`	`Vector4`	`0x260`	scripted
`hitDirection`	`Vector4`	`0x270`	scripted
`hitDirectionToInt`	`int`	`0x280`	scripted
`overridenHitDirection`	`bool`	`0x284`	scripted
`lastHitReactionBehaviorData`	`HitReactionBehaviorData?`	`0x288`	scripted
`lastStimName`	`CName`	`0x298`	scripted
`deathStimName`	`CName`	`0x2A0`	scripted
`meleeHitCount`	`int`	`0x2A8`	scripted
`strongMeleeHitCount`	`int`	`0x2AC`	scripted
`meleeBaseMaxHitChain`	`int`	`0x2B0`	scripted
`rangedBaseMaxHitChain`	`int`	`0x2B4`	scripted
`maxHitChainForMelee`	`int`	`0x2B8`	scripted
`maxHitChainForRanged`	`int`	`0x2BC`	scripted
`isAlive`	`bool`	`0x2C0`	scripted
`frameDamageHealthFactor`	`float`	`0x2C4`	scripted
`hitCountArrayEnd`	`int`	`0x458`	scripted
`hitCountArrayCurrent`	`int`	`0x45C`	scripted
`allowDefeatedOnCompanion`	`bool`	`0x460`	scripted
`baseCumulativeDamagesDecreaser`	`float`	`0x464`	scripted
`blockCountInterval`	`float`	`0x468`	scripted
`dodgeCountInterval`	`float`	`0x46C`	scripted
`globalHitTimer`	`float`	`0x470`	scripted
`hasMantisBladesinRecord`	`bool`	`0x474`	scripted
`indicatorEnabledBlackboardId`	`red.CallbackObject?`	`0x478`	scripted
`hitIndicatorEnabled`	`bool`	`0x488`	scripted
`hasBeenWounded`	`bool`	`0x489`	scripted
`inWorkspot`	`bool`	`0x48A`	scripted
`inCover`	`bool`	`0x48B`	scripted
`healthListener`	`NPCHealthListener?`	`0x490`	scripted
`hitReactionComponentStatsListener`	`NPCHitReactionComponentStatsListener?`	`0x4A0`	scripted
`currentHealth`	`float`	`0x4B0`	scripted
`totalHealth`	`float`	`0x4B4`	scripted
`totalStamina`	`float`	`0x4B8`	scripted
`currentCanDropWeapon`	`float`	`0x4BC`	scripted
`currentExtendedHitReactionImmunity`	`float`	`0x4C0`	scripted
`currentIsInvulnerable`	`float`	`0x4C4`	scripted
`currentDefeatedDamageThreshold`	`float`	`0x4C8`	scripted
`currentImpactDamageThreshold`	`float`	`0x4CC`	scripted
`currentImpactDamageThresholdInCover`	`float`	`0x4D0`	scripted
`currentKnockdownDamageThreshold`	`float`	`0x4D4`	scripted
`currentKnockdownDamageThresholdImpulse`	`float`	`0x4D8`	scripted
`currentKnockdownDamageThresholdInCover`	`float`	`0x4DC`	scripted
`currentKnockdownImmunity`	`float`	`0x4E0`	scripted
`currentMeleeHitReactionResistance`	`float`	`0x4E4`	scripted
`currentStaggerDamageThreshold`	`float`	`0x4E8`	scripted
`currentStaggerDamageThresholdInCover`	`float`	`0x4EC`	scripted
`currentCanBlock`	`float`	`0x4F0`	scripted
`currentHasKerenzikov`	`float`	`0x4F4`	scripted
`dismemberExecuteHealthRange`	`Vector2`	`0x4F8`	scripted
`dismemberExecuteDistanceRange`	`Vector2`	`0x500`	scripted
`executeDismembered`	`bool`	`0x508`	scripted
`attackIsValidBodyPerk`	`bool`	`0x509`	scripted
`invalidForExecuteDismember`	`bool`	`0x50A`	scripted
`hitReactionData`	`anim.AnimFeature_HitReactionsData?`	`0x510`	scripted

Functions

void UpdateDBParams(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateDBParams;ScriptTaskData",
    (HitReactionComponent_UpdateDBParams x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateDBParams(
    HitReactionComponent self,
    game.ScriptTaskData? data
);

void GetDBParameters() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "GetDBParameters;",
    (HitReactionComponent_GetDBParameters x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetDBParameters(
    HitReactionComponent self
);

int GetMeleeMaxHitChain() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetMeleeMaxHitChain;",
    (HitReactionComponent_GetMeleeMaxHitChain x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetMeleeMaxHitChain(
    HitReactionComponent self
);

int GetRangedMaxHitChain() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetRangedMaxHitChain;",
    (HitReactionComponent_GetRangedMaxHitChain x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetRangedMaxHitChain(
    HitReactionComponent self
);

bool GetDeathHasBeenPlayed() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetDeathHasBeenPlayed;",
    (HitReactionComponent_GetDeathHasBeenPlayed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetDeathHasBeenPlayed(
    HitReactionComponent self
);

bool GetDefeatedHasBeenPlayed() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetDefeatedHasBeenPlayed;",
    (HitReactionComponent_GetDefeatedHasBeenPlayed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetDefeatedHasBeenPlayed(
    HitReactionComponent self
);

bool IsExecutedByDismemberment() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "IsExecutedByDismemberment;",
    (HitReactionComponent_IsExecutedByDismemberment x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_IsExecutedByDismemberment(
    HitReactionComponent self
);

int GetHitCountInCombo() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetHitCountInCombo;",
    (HitReactionComponent_GetHitCountInCombo x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetHitCountInCombo(
    HitReactionComponent self
);

int GetStrongHitCountInCombo() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetStrongHitCountInCombo;",
    (HitReactionComponent_GetStrongHitCountInCombo x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetStrongHitCountInCombo(
    HitReactionComponent self
);

CName GetLastStimName() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetLastStimName;",
    (HitReactionComponent_GetLastStimName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetLastStimName(
    HitReactionComponent self
);

CName GetDeathStimName() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetDeathStimName;",
    (HitReactionComponent_GetDeathStimName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetDeathStimName(
    HitReactionComponent self
);

int GetHitReactionType() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetHitReactionType;",
    (HitReactionComponent_GetHitReactionType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetHitReactionType(
    HitReactionComponent self
);

CName GetAttackTag() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetAttackTag;",
    (HitReactionComponent_GetAttackTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetAttackTag(
    HitReactionComponent self
);

game.data.AttackType GetAttackType() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetAttackType;",
    (HitReactionComponent_GetAttackType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AttackType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetAttackType(
    HitReactionComponent self
);

game.data.AttackSubtype GetSubAttackSubType() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetSubAttackSubType(
    HitReactionComponent self
);

anim.AnimFeature_HitReactionsData? GetHitReactionData() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetHitReactionData;",
    (HitReactionComponent_GetHitReactionData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.anim.AnimFeature_HitReactionsData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetHitReactionData(
    HitReactionComponent self
);

anim.AnimFeature_HitReactionsData? GetLastHitReactionData() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetLastHitReactionData;",
    (HitReactionComponent_GetLastHitReactionData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.anim.AnimFeature_HitReactionsData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetLastHitReactionData(
    HitReactionComponent self
);

int GetBlockCount() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetBlockCount;",
    (HitReactionComponent_GetBlockCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetBlockCount(
    HitReactionComponent self
);

int GetParryCount() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetParryCount;",
    (HitReactionComponent_GetParryCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetParryCount(
    HitReactionComponent self
);

int GetDodgeCount() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetDodgeCount;",
    (HitReactionComponent_GetDodgeCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetDodgeCount(
    HitReactionComponent self
);

float GetCumulatedDamage() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetCumulatedDamage;",
    (HitReactionComponent_GetCumulatedDamage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetCumulatedDamage(
    HitReactionComponent self
);

HitReactionBehaviorData? GetLastHitReactionBehaviorData() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetLastHitReactionBehaviorData;",
    (HitReactionComponent_GetLastHitReactionBehaviorData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.HitReactionBehaviorData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetLastHitReactionBehaviorData(
    HitReactionComponent self
);

ActionHitReactionScriptProxy? GetHitReactionProxyAction() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetHitReactionProxyAction;",
    (HitReactionComponent_GetHitReactionProxyAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ActionHitReactionScriptProxy>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetHitReactionProxyAction(
    HitReactionComponent self
);

uint GetLastStimID() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetLastStimID;",
    (HitReactionComponent_GetLastStimID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetLastStimID(
    HitReactionComponent self
);

WeakHandle<game.Object> GetHitSource() RTTI
WeakHandle<game.Object> GetHitInstigator() RTTI

Vector4 GetHitPosition() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetHitPosition;",
    (HitReactionComponent_GetHitPosition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetHitPosition(
    HitReactionComponent self
);

Vector4 GetHitDirection() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetHitDirection;",
    (HitReactionComponent_GetHitDirection x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetHitDirection(
    HitReactionComponent self
);

int GetAttackDirection() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetAttackDirection;",
    (HitReactionComponent_GetAttackDirection x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetAttackDirection(
    HitReactionComponent self
);

bool GetCanBlock() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetCanBlock;",
    (HitReactionComponent_GetCanBlock x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetCanBlock(
    HitReactionComponent self
);

bool GetHasKerenzikov() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetHasKerenzikov;",
    (HitReactionComponent_GetHasKerenzikov x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetHasKerenzikov(
    HitReactionComponent self
);

bool GetShouldEvade() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetShouldEvade;",
    (HitReactionComponent_GetShouldEvade x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetShouldEvade(
    HitReactionComponent self
);

Vector4 GetOverridenHitDirection() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetOverridenHitDirection;",
    (HitReactionComponent_GetOverridenHitDirection x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetOverridenHitDirection(
    HitReactionComponent self
);

int GetHitDirectionToInt() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetHitDirectionToInt;",
    (HitReactionComponent_GetHitDirectionToInt x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetHitDirectionToInt(
    HitReactionComponent self
);

float GetRagdollImpulse() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetRagdollImpulse;",
    (HitReactionComponent_GetRagdollImpulse x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetRagdollImpulse(
    HitReactionComponent self
);

bool IsInKnockdown() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "IsInKnockdown;",
    (HitReactionComponent_IsInKnockdown x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_IsInKnockdown(
    HitReactionComponent self
);

bool GetHitAnimationInProgress() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetHitAnimationInProgress;",
    (HitReactionComponent_GetHitAnimationInProgress x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetHitAnimationInProgress(
    HitReactionComponent self
);

void UpdateOwnerHealthData(float Value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateOwnerHealthData;Float",
    (HitReactionComponent_UpdateOwnerHealthData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateOwnerHealthData(
    HitReactionComponent self,
    float Value
);

void UpdateOwnerCanDropWeaponData(float Value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateOwnerCanDropWeaponData;Float",
    (HitReactionComponent_UpdateOwnerCanDropWeaponData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateOwnerCanDropWeaponData(
    HitReactionComponent self,
    float Value
);

void UpdateOwnerExtendedHitReactionImmunityData(float Value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateOwnerExtendedHitReactionImmunityData;Float",
    (HitReactionComponent_UpdateOwnerExtendedHitReactionImmunityData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateOwnerExtendedHitReactionImmunityData(
    HitReactionComponent self,
    float Value
);

void UpdateOwnerIsInvulnerableData(float Value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateOwnerIsInvulnerableData;Float",
    (HitReactionComponent_UpdateOwnerIsInvulnerableData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateOwnerIsInvulnerableData(
    HitReactionComponent self,
    float Value
);

void UpdateOwnerImpactDamageThresholdData(float Value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateOwnerImpactDamageThresholdData;Float",
    (HitReactionComponent_UpdateOwnerImpactDamageThresholdData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateOwnerImpactDamageThresholdData(
    HitReactionComponent self,
    float Value
);

void UpdateOwnerImpactDamageThresholdInCoverData(float Value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateOwnerImpactDamageThresholdInCoverData;Float",
    (HitReactionComponent_UpdateOwnerImpactDamageThresholdInCoverData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateOwnerImpactDamageThresholdInCoverData(
    HitReactionComponent self,
    float Value
);

void UpdateOwnerKnockdownDamageThresholdData(float Value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateOwnerKnockdownDamageThresholdData;Float",
    (HitReactionComponent_UpdateOwnerKnockdownDamageThresholdData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateOwnerKnockdownDamageThresholdData(
    HitReactionComponent self,
    float Value
);

void UpdateOwnerKnockdownDamageThresholdImpulseData(float Value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateOwnerKnockdownDamageThresholdImpulseData;Float",
    (HitReactionComponent_UpdateOwnerKnockdownDamageThresholdImpulseData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateOwnerKnockdownDamageThresholdImpulseData(
    HitReactionComponent self,
    float Value
);

void UpdateOwnerKnockdownDamageThresholdInCoverData(float Value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateOwnerKnockdownDamageThresholdInCoverData;Float",
    (HitReactionComponent_UpdateOwnerKnockdownDamageThresholdInCoverData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateOwnerKnockdownDamageThresholdInCoverData(
    HitReactionComponent self,
    float Value
);

void UpdateOwnerKnockdownImmunityData(float Value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateOwnerKnockdownImmunityData;Float",
    (HitReactionComponent_UpdateOwnerKnockdownImmunityData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateOwnerKnockdownImmunityData(
    HitReactionComponent self,
    float Value
);

void UpdateOwnerMeleeHitReactionResistanceData(float Value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateOwnerMeleeHitReactionResistanceData;Float",
    (HitReactionComponent_UpdateOwnerMeleeHitReactionResistanceData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateOwnerMeleeHitReactionResistanceData(
    HitReactionComponent self,
    float Value
);

void UpdateOwnerStaggerDamageThresholdData(float Value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateOwnerStaggerDamageThresholdData;Float",
    (HitReactionComponent_UpdateOwnerStaggerDamageThresholdData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateOwnerStaggerDamageThresholdData(
    HitReactionComponent self,
    float Value
);

void UpdateOwnerStaggerDamageThresholdInCoverData(float Value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateOwnerStaggerDamageThresholdInCoverData;Float",
    (HitReactionComponent_UpdateOwnerStaggerDamageThresholdInCoverData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateOwnerStaggerDamageThresholdInCoverData(
    HitReactionComponent self,
    float Value
);

void UpdateOwnerCanBlockData(float Value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateOwnerCanBlockData;Float",
    (HitReactionComponent_UpdateOwnerCanBlockData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateOwnerCanBlockData(
    HitReactionComponent self,
    float Value
);

void UpdateOwnerHasKerenzikovData(float Value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateOwnerHasKerenzikovData;Float",
    (HitReactionComponent_UpdateOwnerHasKerenzikovData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateOwnerHasKerenzikovData(
    HitReactionComponent self,
    float Value
);

void UpdateDeathHasBeenPlayed() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateDeathHasBeenPlayed;",
    (HitReactionComponent_UpdateDeathHasBeenPlayed x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateDeathHasBeenPlayed(
    HitReactionComponent self
);

uint UpdateLastStimID() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "UpdateLastStimID;",
    (HitReactionComponent_UpdateLastStimID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateLastStimID(
    HitReactionComponent self
);

void ResetHitCount() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "ResetHitCount;",
    (HitReactionComponent_ResetHitCount x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_ResetHitCount(
    HitReactionComponent self
);

void SetLastStimName(CName laststimName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "SetLastStimName;CName",
    (HitReactionComponent_SetLastStimName x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_SetLastStimName(
    HitReactionComponent self,
    CName laststimName
);

void SetDeathStimName(CName laststimName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "SetDeathStimName;CName",
    (HitReactionComponent_SetDeathStimName x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_SetDeathStimName(
    HitReactionComponent self,
    CName laststimName
);

void UpdateBlockCount() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateBlockCount;",
    (HitReactionComponent_UpdateBlockCount x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateBlockCount(
    HitReactionComponent self
);

void UpdateParryCount() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateParryCount;",
    (HitReactionComponent_UpdateParryCount x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateParryCount(
    HitReactionComponent self
);

void UpdateDodgeCount() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateDodgeCount;",
    (HitReactionComponent_UpdateDodgeCount x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateDodgeCount(
    HitReactionComponent self
);

float GetHealthPecentageNormalized() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetHealthPecentageNormalized;",
    (HitReactionComponent_GetHealthPecentageNormalized x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetHealthPecentageNormalized(
    HitReactionComponent self
);

float GetFrameDamage() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetFrameDamage;",
    (HitReactionComponent_GetFrameDamage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetFrameDamage(
    HitReactionComponent self
);

float GetPhysicalImpulse(game.damage.AttackData attackData, Vector4 hitPosition, out float frameImpulse) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetPhysicalImpulse;AttackDataVector4Float",
    (HitReactionComponent_GetPhysicalImpulse x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetPhysicalImpulse(
    HitReactionComponent self,
    game.damage.AttackData? attackData,
    Vector4 hitPosition,
    float frameImpulse
);

float GetFrameWoundsDamage() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetFrameWoundsDamage;",
    (HitReactionComponent_GetFrameWoundsDamage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetFrameWoundsDamage(
    HitReactionComponent self
);

float GetFrameDismembermentDamage() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetFrameDismembermentDamage;",
    (HitReactionComponent_GetFrameDismembermentDamage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetFrameDismembermentDamage(
    HitReactionComponent self
);

float GetOwnerHPPercentage() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetOwnerHPPercentage;",
    (HitReactionComponent_GetOwnerHPPercentage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetOwnerHPPercentage(
    HitReactionComponent self
);

HitShapeUserDataBase? GetHitShapeUserData() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetHitShapeUserData;",
    (HitReactionComponent_GetHitShapeUserData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.HitShapeUserDataBase>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetHitShapeUserData(
    HitReactionComponent self
);

void ResetFrameDamage() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "ResetFrameDamage;",
    (HitReactionComponent_ResetFrameDamage x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_ResetFrameDamage(
    HitReactionComponent self
);

float GetCurrentTime() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetCurrentTime;",
    (HitReactionComponent_GetCurrentTime x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetCurrentTime(
    HitReactionComponent self
);

bool IsOwnerFacingInstigator() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "IsOwnerFacingInstigator;",
    (HitReactionComponent_IsOwnerFacingInstigator x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_IsOwnerFacingInstigator(
    HitReactionComponent self
);

void NotifyAboutWoundedInstigated(WeakHandle<game.Object> instigator, EHitReactionZone bodyPart) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "NotifyAboutWoundedInstigated;GameObjectEHitReactionZone",
    (HitReactionComponent_NotifyAboutWoundedInstigated x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_NotifyAboutWoundedInstigated(
    HitReactionComponent self,
    WeakHandle<game.Object> instigator,
    EHitReactionZone bodyPart
);

void NotifyAboutDismembermentInstigated(WeakHandle<game.Object> instigator, EHitReactionZone bodyPart, Vector4 targetPosition)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "NotifyAboutDismembermentInstigated;GameObjectEHitReactionZoneVector4",
    (HitReactionComponent_NotifyAboutDismembermentInstigated x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_NotifyAboutDismembermentInstigated(
    HitReactionComponent self,
    WeakHandle<game.Object> instigator,
    EHitReactionZone bodyPart,
    Vector4 targetPosition
);

float GetOwnerTotalHealth() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetOwnerTotalHealth;",
    (HitReactionComponent_GetOwnerTotalHealth x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetOwnerTotalHealth(
    HitReactionComponent self
);

float GetOwnerCurrentHealth() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetOwnerCurrentHealth;",
    (HitReactionComponent_GetOwnerCurrentHealth x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetOwnerCurrentHealth(
    HitReactionComponent self
);

float GetIsOwnerImmuneToExtendedHitReaction() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetIsOwnerImmuneToExtendedHitReaction;",
    (HitReactionComponent_GetIsOwnerImmuneToExtendedHitReaction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetIsOwnerImmuneToExtendedHitReaction(
    HitReactionComponent self
);

bool GetIsOwnerResistantToMeleeHitReaction() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetIsOwnerResistantToMeleeHitReaction;",
    (HitReactionComponent_GetIsOwnerResistantToMeleeHitReaction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetIsOwnerResistantToMeleeHitReaction(
    HitReactionComponent self
);

void OnGameAttach() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "OnGameAttach;",
    (HitReactionComponent_OnGameAttach x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_OnGameAttach(
    HitReactionComponent self
);

void OnGameAttached() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "OnGameAttached;",
    (HitReactionComponent_OnGameAttached x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_OnGameAttached(
    HitReactionComponent self
);

void OnGameDetach() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "OnGameDetach;",
    (HitReactionComponent_OnGameDetach x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_OnGameDetach(
    HitReactionComponent self
);

bool OnItemAddedToSlot(game.AttachmentSlotEventsItemAddedToSlot evt) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "OnItemAddedToSlot",
    (HitReactionComponent_OnItemAddedToSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_OnItemAddedToSlot(
    HitReactionComponent self,
    game.AttachmentSlotEventsItemAddedToSlot? evt
);

bool OnDefeated(game.events.DefeatedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "OnDefeated",
    (HitReactionComponent_OnDefeated x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_OnDefeated(
    HitReactionComponent self,
    game.events.DefeatedEvent? evt
);

bool OnDeath(game.events.DeathEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "OnDeath",
    (HitReactionComponent_OnDeath x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_OnDeath(
    HitReactionComponent self,
    game.events.DeathEvent? evt
);

bool OnHitIndicatorEnabledChanged(bool value) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "OnHitIndicatorEnabledChanged",
    (HitReactionComponent_OnHitIndicatorEnabledChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_OnHitIndicatorEnabledChanged(
    HitReactionComponent self,
    bool value
);

bool OnResurrect(game.events.ResurrectEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "OnResurrect",
    (HitReactionComponent_OnResurrect x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_OnResurrect(
    HitReactionComponent self,
    game.events.ResurrectEvent? evt
);

bool OnHitReactionCumulativeDamageUpdate(HitReactionCumulativeDamageUpdate evt) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "OnHitReactionCumulativeDamageUpdate",
    (HitReactionComponent_OnHitReactionCumulativeDamageUpdate x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_OnHitReactionCumulativeDamageUpdate(
    HitReactionComponent self,
    HitReactionCumulativeDamageUpdate? evt
);

void RequestCumulativeDamageUpdate() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "RequestCumulativeDamageUpdate;",
    (HitReactionComponent_RequestCumulativeDamageUpdate x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_RequestCumulativeDamageUpdate(
    HitReactionComponent self
);

bool OnHitReactionStopMotionExtraction(HitReactionStopMotionExtraction evt) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "OnHitReactionStopMotionExtraction",
    (HitReactionComponent_OnHitReactionStopMotionExtraction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_OnHitReactionStopMotionExtraction(
    HitReactionComponent self,
    HitReactionStopMotionExtraction? evt
);

bool OnRequestHitReaction(HitReactionRequest evt) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "OnRequestHitReaction",
    (HitReactionComponent_OnRequestHitReaction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_OnRequestHitReaction(
    HitReactionComponent self,
    HitReactionRequest? evt
);

bool OnForcedHitReaction(ForcedHitReactionEvent forcedHitReaction) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "OnForcedHitReaction",
    (HitReactionComponent_OnForcedHitReaction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_OnForcedHitReaction(
    HitReactionComponent self,
    ForcedHitReactionEvent? forcedHitReaction
);

bool OnForcedDeathEvent(ForcedDeathEvent forcedDeath) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "OnForcedDeathEvent",
    (HitReactionComponent_OnForcedDeathEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_OnForcedDeathEvent(
    HitReactionComponent self,
    ForcedDeathEvent? forcedDeath
);

bool OnSetLastHitReactionBehaviorData(LastHitDataEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "OnSetLastHitReactionBehaviorData",
    (HitReactionComponent_OnSetLastHitReactionBehaviorData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_OnSetLastHitReactionBehaviorData(
    HitReactionComponent self,
    LastHitDataEvent? evt
);

bool OnSetNewHitReactionBehaviorData(NewHitDataEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "OnSetNewHitReactionBehaviorData",
    (HitReactionComponent_OnSetNewHitReactionBehaviorData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_OnSetNewHitReactionBehaviorData(
    HitReactionComponent self,
    NewHitDataEvent? evt
);

bool IsSoundCriticalHit(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "IsSoundCriticalHit;gameHitEvent",
    (HitReactionComponent_IsSoundCriticalHit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

CName GetKillSoundName(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetKillSoundName;gameHitEvent",
    (HitReactionComponent_GetKillSoundName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

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

CName GetHitSoundName(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetHitSoundName;gameHitEvent",
    (HitReactionComponent_GetHitSoundName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

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

void EvaluateHit(game.events.HitEvent newHitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "EvaluateHit;gameHitEvent",
    (HitReactionComponent_EvaluateHit x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_EvaluateHit(
    HitReactionComponent self,
    game.events.HitEvent? newHitEvent
);

void UpdateCoverDamage(NPCPuppet npc, ulong coverId) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateCoverDamage;NPCPuppetUint64",
    (HitReactionComponent_UpdateCoverDamage x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateCoverDamage(
    HitReactionComponent self,
    NPCPuppet? npc,
    ulong coverId
);

void CacheVars(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "CacheVars;gameHitEvent",
    (HitReactionComponent_CacheVars x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void IncrementHitCountData() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "IncrementHitCountData;",
    (HitReactionComponent_IncrementHitCountData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_IncrementHitCountData(
    HitReactionComponent self
);

float GetHitCountData(int index) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetHitCountData;Int32",
    (HitReactionComponent_GetHitCountData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetHitCountData(
    HitReactionComponent self,
    int index
);

int GetHitCountDataArrayCurrent() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetHitCountDataArrayCurrent;",
    (HitReactionComponent_GetHitCountDataArrayCurrent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetHitCountDataArrayCurrent(
    HitReactionComponent self
);

int GetHitCountDataArrayEnd() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetHitCountDataArrayEnd;",
    (HitReactionComponent_GetHitCountDataArrayEnd x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetHitCountDataArrayEnd(
    HitReactionComponent self
);

void SetHitReactionType(anim.HitReactionType hitType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "SetHitReactionType;animHitReactionType",
    (HitReactionComponent_SetHitReactionType x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_SetHitReactionType(
    HitReactionComponent self,
    anim.HitReactionType hitType
);

void SetHitReactionSource(EAIHitSource hitSource) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "SetHitReactionSource;EAIHitSource",
    (HitReactionComponent_SetHitReactionSource x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_SetHitReactionSource(
    HitReactionComponent self,
    EAIHitSource hitSource
);

void SetStance() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "SetStance;",
    (HitReactionComponent_SetStance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_SetStance(
    HitReactionComponent self
);

void SetHitReactionThresholds() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "SetHitReactionThresholds;",
    (HitReactionComponent_SetHitReactionThresholds x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_SetHitReactionThresholds(
    HitReactionComponent self
);

void SetHitReactionImmunities() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "SetHitReactionImmunities;",
    (HitReactionComponent_SetHitReactionImmunities x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_SetHitReactionImmunities(
    HitReactionComponent self
);

bool GetHitTimerAvailability() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetHitTimerAvailability;",
    (HitReactionComponent_GetHitTimerAvailability x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetHitTimerAvailability(
    HitReactionComponent self
);

void SetCumulatedDamages(WeakHandle<game.Object> target, out float guardBreakImpulse) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "SetCumulatedDamages;GameObjectFloat",
    (HitReactionComponent_SetCumulatedDamages x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_SetCumulatedDamages(
    HitReactionComponent self,
    WeakHandle<game.Object> target,
    float guardBreakImpulse
);

void SetCumulatedDamagesForDeadNPC() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "SetCumulatedDamagesForDeadNPC;",
    (HitReactionComponent_SetCumulatedDamagesForDeadNPC x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_SetCumulatedDamagesForDeadNPC(
    HitReactionComponent self
);

bool UpdateCumulatedDamages(float deltaTime) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "UpdateCumulatedDamages;Float",
    (HitReactionComponent_UpdateCumulatedDamages x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateCumulatedDamages(
    HitReactionComponent self,
    float deltaTime
);

bool GetBodyPart(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetBodyPart;gameHitEvent",
    (HitReactionComponent_GetBodyPart x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool CheckInstantDismembermentOnDeath() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "CheckInstantDismembermentOnDeath;",
    (HitReactionComponent_CheckInstantDismembermentOnDeath x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_CheckInstantDismembermentOnDeath(
    HitReactionComponent self
);

game.DismWoundType GetDismembermentWoundType() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetDismembermentWoundType;",
    (HitReactionComponent_GetDismembermentWoundType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.DismWoundType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetDismembermentWoundType(
    HitReactionComponent self
);

EHitReactionZone ProcessHitReactionZone(EHitReactionZone bodyPart) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "ProcessHitReactionZone;EHitReactionZone",
    (HitReactionComponent_ProcessHitReactionZone x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EHitReactionZone>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_ProcessHitReactionZone(
    HitReactionComponent self,
    EHitReactionZone bodyPart
);

bool ProcessDefeated(NPCPuppet npc) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "ProcessDefeated;NPCPuppet",
    (HitReactionComponent_ProcessDefeated x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_ProcessDefeated(
    HitReactionComponent self,
    NPCPuppet? npc
);

void UpdateDefeated() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "UpdateDefeated;",
    (HitReactionComponent_UpdateDefeated x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_UpdateDefeated(
    HitReactionComponent self
);

bool DefeatedRemoveConditions(NPCPuppet npc) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "DefeatedRemoveConditions;NPCPuppet",
    (HitReactionComponent_DefeatedRemoveConditions x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_DefeatedRemoveConditions(
    HitReactionComponent self,
    NPCPuppet? npc
);

bool CheckBrainMeltDeath() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "CheckBrainMeltDeath;",
    (HitReactionComponent_CheckBrainMeltDeath x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_CheckBrainMeltDeath(
    HitReactionComponent self
);

void ProcessDropWeaponOnHit(game.Object owner, EHitReactionZone hitBodyPart, anim.HitReactionType hitReaction) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "ProcessDropWeaponOnHit;GameObjectEHitReactionZoneanimHitReactionType",
    (HitReactionComponent_ProcessDropWeaponOnHit x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_ProcessDropWeaponOnHit(
    HitReactionComponent self,
    game.Object? owner,
    EHitReactionZone hitBodyPart,
    anim.HitReactionType hitReaction
);

void ProcessExtendedDeathAnimData(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "ProcessExtendedDeathAnimData;gameHitEvent",
    (HitReactionComponent_ProcessExtendedDeathAnimData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void ProcessExtendedHitReactionAnimData(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "ProcessExtendedHitReactionAnimData;gameHitEvent",
    (HitReactionComponent_ProcessExtendedHitReactionAnimData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void ProcessSpecialFX(game.events.HitEvent hitevent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "ProcessSpecialFX;gameHitEvent",
    (HitReactionComponent_ProcessSpecialFX x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_ProcessSpecialFX(
    HitReactionComponent self,
    game.events.HitEvent? hitevent
);

void ProcessWoundsAndDismemberment() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "ProcessWoundsAndDismemberment;",
    (HitReactionComponent_ProcessWoundsAndDismemberment x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_ProcessWoundsAndDismemberment(
    HitReactionComponent self
);

EBarkList ReactionZoneEnumToBarkListEnum(EHitReactionZone reactionZone) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "ReactionZoneEnumToBarkListEnum;EHitReactionZone",
    (HitReactionComponent_ReactionZoneEnumToBarkListEnum x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EBarkList>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_ReactionZoneEnumToBarkListEnum(
    HitReactionComponent self,
    EHitReactionZone reactionZone
);

int ReactionZoneEnumToBodyPartID(EHitReactionZone reactionZone) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "ReactionZoneEnumToBodyPartID;EHitReactionZone",
    (HitReactionComponent_ReactionZoneEnumToBodyPartID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_ReactionZoneEnumToBodyPartID(
    HitReactionComponent self,
    EHitReactionZone reactionZone
);

bool WoundedBaseConditions() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "WoundedBaseConditions;",
    (HitReactionComponent_WoundedBaseConditions x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_WoundedBaseConditions(
    HitReactionComponent self
);

bool WoundedFleshConditions(bool dismembermentCheck, bool woundedBaseConditions) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "WoundedFleshConditions;BoolBool",
    (HitReactionComponent_WoundedFleshConditions x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_WoundedFleshConditions(
    HitReactionComponent self,
    bool dismembermentCheck,
    bool woundedBaseConditions
);

bool WoundedCyberConditions(bool dismembermentCheck, bool woundedBaseConditions) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "WoundedCyberConditions;BoolBool",
    (HitReactionComponent_WoundedCyberConditions x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_WoundedCyberConditions(
    HitReactionComponent self,
    bool dismembermentCheck,
    bool woundedBaseConditions
);

bool CanDieCondition(bool? doNotCheckAttackData) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "CanDieCondition;Bool",
    (HitReactionComponent_CanDieCondition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_CanDieCondition(
    HitReactionComponent self,
    bool? doNotCheckAttackData
);

bool DismembermentConditions() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "DismembermentConditions;",
    (HitReactionComponent_DismembermentConditions x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_DismembermentConditions(
    HitReactionComponent self
);

void ProcessFragmentationSplinterReaction(Vector4 hitPosition) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "ProcessFragmentationSplinterReaction;Vector4",
    (HitReactionComponent_ProcessFragmentationSplinterReaction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_ProcessFragmentationSplinterReaction(
    HitReactionComponent self,
    Vector4 hitPosition
);

bool IsValidBodyPerkDismemberAttack(float healthMissing) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "IsValidBodyPerkDismemberAttack;Float",
    (HitReactionComponent_IsValidBodyPerkDismemberAttack x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_IsValidBodyPerkDismemberAttack(
    HitReactionComponent self,
    float healthMissing
);

bool TryTriggerBodyPerkDismembement(float remainingHealth) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "TryTriggerBodyPerkDismembement;Float",
    (HitReactionComponent_TryTriggerBodyPerkDismembement x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_TryTriggerBodyPerkDismembement(
    HitReactionComponent self,
    float remainingHealth
);

void IncrementBodyPerkDismembermentChance(WeakHandle<game.Object> player) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "IncrementBodyPerkDismembermentChance;GameObject",
    (HitReactionComponent_IncrementBodyPerkDismembermentChance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_IncrementBodyPerkDismembermentChance(
    HitReactionComponent self,
    WeakHandle<game.Object> player
);

void ClearBodyPerkDismembermentChance(WeakHandle<game.Object> player) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "ClearBodyPerkDismembermentChance;GameObject",
    (HitReactionComponent_ClearBodyPerkDismembermentChance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_ClearBodyPerkDismembermentChance(
    HitReactionComponent self,
    WeakHandle<game.Object> player
);

void ProcessBodyPerkDismembement() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "ProcessBodyPerkDismembement;",
    (HitReactionComponent_ProcessBodyPerkDismembement x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_ProcessBodyPerkDismembement(
    HitReactionComponent self
);

void ProcessOnePunchAttackHitImpact(ScriptedPuppet target, game.Object instigator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "ProcessOnePunchAttackHitImpact;ScriptedPuppetGameObject",
    (HitReactionComponent_ProcessOnePunchAttackHitImpact x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_ProcessOnePunchAttackHitImpact(
    HitReactionComponent self,
    ScriptedPuppet? target,
    game.Object? instigator
);

void ProcessGrandFinaleHitImpact(ScriptedPuppet target, game.Object instigator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "ProcessGrandFinaleHitImpact;ScriptedPuppetGameObject",
    (HitReactionComponent_ProcessGrandFinaleHitImpact x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_ProcessGrandFinaleHitImpact(
    HitReactionComponent self,
    ScriptedPuppet? target,
    game.Object? instigator
);

bool OnPlayOnePunchVFX(PlayOnePunchVFX evt) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "OnPlayOnePunchVFX",
    (HitReactionComponent_OnPlayOnePunchVFX x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_OnPlayOnePunchVFX(
    HitReactionComponent self,
    PlayOnePunchVFX? evt
);

bool OnPlayGrandFinaleVFX(PlayGrandFinaleVFX evt) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "OnPlayGrandFinaleVFX",
    (HitReactionComponent_OnPlayGrandFinaleVFX x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_OnPlayGrandFinaleVFX(
    HitReactionComponent self,
    PlayGrandFinaleVFX? evt
);

void ProcessExplosionDismembement() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "ProcessExplosionDismembement;",
    (HitReactionComponent_ProcessExplosionDismembement x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_ProcessExplosionDismembement(
    HitReactionComponent self
);

void SendDismembermentCriticalEvent(game.DismWoundType dismembermentType, game.DismBodyPart bodyPart, Vector4 explosionEpicentrum, float strength, Vector4 hitPosition)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "SendDismembermentCriticalEvent;gameDismWoundTypegameDismBodyPartVector4FloatVector4",
    (HitReactionComponent_SendDismembermentCriticalEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_SendDismembermentCriticalEvent(
    HitReactionComponent self,
    game.DismWoundType dismembermentType,
    game.DismBodyPart bodyPart,
    Vector4 explosionEpicentrum,
    float strength,
    Vector4 hitPosition
);

void GetHitIntensity(bool defeatedOverride) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "GetHitIntensity;Bool",
    (HitReactionComponent_GetHitIntensity x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetHitIntensity(
    HitReactionComponent self,
    bool defeatedOverride
);

bool IsPowerDifferenceBelow(game.EPowerDifferential powerDifferential) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "IsPowerDifferenceBelow;gameEPowerDifferential",
    (HitReactionComponent_IsPowerDifferenceBelow x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_IsPowerDifferenceBelow(
    HitReactionComponent self,
    game.EPowerDifferential powerDifferential
);

anim.HitReactionType GetReactionType(float guardBreakImpulse, game.events.HitEvent newHitEvent) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetReactionType;FloatgameHitEvent",
    (HitReactionComponent_GetReactionType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.anim.HitReactionType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetReactionType(
    HitReactionComponent self,
    float guardBreakImpulse,
    game.events.HitEvent? newHitEvent
);

bool CanAttackGuardBreak(game.data.ItemType weaponType, float guardBreakImpulse) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "CanAttackGuardBreak;gamedataItemTypeFloat",
    (HitReactionComponent_CanAttackGuardBreak x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_CanAttackGuardBreak(
    HitReactionComponent self,
    game.data.ItemType weaponType,
    float guardBreakImpulse
);

void StartGuardBreakCooldown() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "StartGuardBreakCooldown;",
    (HitReactionComponent_StartGuardBreakCooldown x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_StartGuardBreakCooldown(
    HitReactionComponent self
);

bool IsStrongExplosion(game.damage.AttackData attackData) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "IsStrongExplosion;AttackData",
    (HitReactionComponent_IsStrongExplosion x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void SendDataToAIBehavior(anim.HitReactionType reactionPlayed) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "SendDataToAIBehavior;animHitReactionType",
    (HitReactionComponent_SendDataToAIBehavior x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_SendDataToAIBehavior(
    HitReactionComponent self,
    anim.HitReactionType reactionPlayed
);

void RecalculateHitReactionValsForHacks(float currentTimeStamp, out int hitReactionMin, out int hitReactionMax) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "RecalculateHitReactionValsForHacks;FloatInt32Int32",
    (HitReactionComponent_RecalculateHitReactionValsForHacks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_RecalculateHitReactionValsForHacks(
    HitReactionComponent self,
    float currentTimeStamp,
    int hitReactionMin,
    int hitReactionMax
);

void SendMechDataToAIBehavior(anim.HitReactionType reactionPlayed) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "SendMechDataToAIBehavior;animHitReactionType",
    (HitReactionComponent_SendMechDataToAIBehavior x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_SendMechDataToAIBehavior(
    HitReactionComponent self,
    anim.HitReactionType reactionPlayed
);

void SetHitSource(game.data.AttackType attackType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "SetHitSource;gamedataAttackType",
    (HitReactionComponent_SetHitSource x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_SetHitSource(
    HitReactionComponent self,
    game.data.AttackType attackType
);

void SetAnimVariation(out int hitDirection, out EHitReactionZone hitReactionZone) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "SetAnimVariation;Int32EHitReactionZone",
    (HitReactionComponent_SetAnimVariation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_SetAnimVariation(
    HitReactionComponent self,
    int hitDirection,
    EHitReactionZone hitReactionZone
);

void StoreHitData(int attackAngle, EAIHitIntensity hitSeverity, anim.HitReactionType reactionType, EHitReactionZone bodyPart, int variation)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "StoreHitData;Int32EAIHitIntensityanimHitReactionTypeEHitReactionZoneInt32",
    (HitReactionComponent_StoreHitData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_StoreHitData(
    HitReactionComponent self,
    int attackAngle,
    EAIHitIntensity hitSeverity,
    anim.HitReactionType reactionType,
    EHitReactionZone bodyPart,
    int variation
);

void SendTwitchDataToAnimationGraph() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "SendTwitchDataToAnimationGraph;",
    (HitReactionComponent_SendTwitchDataToAnimationGraph x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_SendTwitchDataToAnimationGraph(
    HitReactionComponent self
);

void SendTwitchDataToPlayerAnimationGraph(WeakHandle<game.Object> playerObject) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "SendTwitchDataToPlayerAnimationGraph;GameObject",
    (HitReactionComponent_SendTwitchDataToPlayerAnimationGraph x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_SendTwitchDataToPlayerAnimationGraph(
    HitReactionComponent self,
    WeakHandle<game.Object> playerObject
);

void SetHitStimEvent(anim.AnimFeature_HitReactionsData hitData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "SetHitStimEvent;AnimFeature_HitReactionsData",
    (HitReactionComponent_SetHitStimEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_SetHitStimEvent(
    HitReactionComponent self,
    anim.AnimFeature_HitReactionsData? hitData
);

anim.AnimFeature_HitReactionsData? GetHitStimEvent() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetHitStimEvent;",
    (HitReactionComponent_GetHitStimEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.anim.AnimFeature_HitReactionsData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetHitStimEvent(
    HitReactionComponent self
);

float GetLastHitTimeStamp() RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "GetLastHitTimeStamp;",
    (HitReactionComponent_GetLastHitTimeStamp x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_GetLastHitTimeStamp(
    HitReactionComponent self
);

bool OnClearHitStimEvent(ClearHitStimEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "OnClearHitStimEvent",
    (HitReactionComponent_OnClearHitStimEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HitReactionComponent_OnClearHitStimEvent(
    HitReactionComponent self,
    ClearHitStimEvent? evt
);

static void ClearHitStim(game.Object obj) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "HitReactionComponent",
    "HitReactionComponent::ClearHitStim;GameObject",
    (HitReactionComponent_ClearHitStim x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static TDBID GetMantisBladesInstantDismembermentSpyBuffStatusEffectID() staticRTTI global

Generated hook

re.Hooks.Place(
    "HitReactionComponent",
    "HitReactionComponent::GetMantisBladesInstantDismembermentSpyBuffStatusEffectID;",
    (HitReactionComponent_GetMantisBladesInstantDismembermentSpyBuffStatusEffectID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

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