class game.damage

AttackData

game.damage.AttackData

20 properties
72 functions

Properties

Property	Type	Offset
`attackType`	`game.data.AttackType`	`0x40`
`instigator`	`WeakHandle<game.Object>`	`0x48`
`source`	`WeakHandle<game.Object>`	`0x58`
`weapon`	`WeakHandle<game.weapon.Object>`	`0x68`
`attackDefinition`	`game.IAttack?`	`0x78`
`attackPosition`	`Vector4`	`0x90`
`weaponCharge`	`float`	`0xA0`
`numRicochetBounces`	`int`	`0xA4`
`numAttackSpread`	`int`	`0xA8`
`attackTime`	`float`	`0xAC`
`triggerMode`	`game.data.TriggerMode`	`0xB0`
`flags`	`SHitFlag[]`	`0x0`	scripted
`statusEffects`	`SHitStatusEffect[]`	`0x10`	scripted
`hitType`	`game.ui.HitType`	`0x20`	scripted
`vehicleImpactForce`	`float`	`0x24`	scripted
`minimumHealthPercent`	`float`	`0x28`	scripted
`additionalCritChance`	`float`	`0x2C`	scripted
`randRoll`	`float`	`0x30`	scripted
`hitReactionMin`	`int`	`0x34`	scripted
`hitReactionMax`	`int`	`0x38`	scripted

Functions

void SetAttackType(game.data.AttackType attackTypeOverride) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "SetAttackType;gamedataAttackType",
    (AttackData_SetAttackType x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_SetAttackType(
    game.damage.AttackData self,
    game.data.AttackType attackTypeOverride
);

void PreAttack() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "PreAttack;",
    (AttackData_PreAttack x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_PreAttack(
    game.damage.AttackData self
);

void SetInstigator(WeakHandle<game.Object> i) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "SetInstigator;GameObject",
    (AttackData_SetInstigator x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_SetInstigator(
    game.damage.AttackData self,
    WeakHandle<game.Object> i
);

void SetSource(WeakHandle<game.Object> s) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "SetSource;GameObject",
    (AttackData_SetSource x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_SetSource(
    game.damage.AttackData self,
    WeakHandle<game.Object> s
);

void SetWeapon(WeakHandle<game.weapon.Object> w) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "SetWeapon;WeaponObject",
    (AttackData_SetWeapon x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_SetWeapon(
    game.damage.AttackData self,
    WeakHandle<game.weapon.Object> w
);

void SetAttackDefinition(game.IAttack a) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "SetAttackDefinition;IAttack",
    (AttackData_SetAttackDefinition x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_SetAttackDefinition(
    game.damage.AttackData self,
    game.IAttack? a
);

void SetHitType(game.ui.HitType h) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "SetHitType;gameuiHitType",
    (AttackData_SetHitType x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_SetHitType(
    game.damage.AttackData self,
    game.ui.HitType h
);

void SetAttackPosition(Vector4 position) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "SetAttackPosition;Vector4",
    (AttackData_SetAttackPosition x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_SetAttackPosition(
    game.damage.AttackData self,
    Vector4 position
);

void SetWeaponCharge(float charge) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "SetWeaponCharge;Float",
    (AttackData_SetWeaponCharge x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_SetWeaponCharge(
    game.damage.AttackData self,
    float charge
);

void SetVehicleImpactForce(float force) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "SetVehicleImpactForce;Float",
    (AttackData_SetVehicleImpactForce x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_SetVehicleImpactForce(
    game.damage.AttackData self,
    float force
);

void SetAdditionalCritChance(float f) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "SetAdditionalCritChance;Float",
    (AttackData_SetAdditionalCritChance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_SetAdditionalCritChance(
    game.damage.AttackData self,
    float f
);

void SetHitReactionSeverityMin(int i) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "SetHitReactionSeverityMin;Int32",
    (AttackData_SetHitReactionSeverityMin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_SetHitReactionSeverityMin(
    game.damage.AttackData self,
    int i
);

void SetHitReactionSeverityMax(int i) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "SetHitReactionSeverityMax;Int32",
    (AttackData_SetHitReactionSeverityMax x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_SetHitReactionSeverityMax(
    game.damage.AttackData self,
    int i
);

void SetAttackTime(float time) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "SetAttackTime;Float",
    (AttackData_SetAttackTime x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_SetAttackTime(
    game.damage.AttackData self,
    float time
);

void SetTriggerMode(game.data.TriggerMode mode) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "SetTriggerMode;gamedataTriggerMode",
    (AttackData_SetTriggerMode x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_SetTriggerMode(
    game.damage.AttackData self,
    game.data.TriggerMode mode
);

void SetRandRoll(float roll) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "SetRandRoll;Float",
    (AttackData_SetRandRoll x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_SetRandRoll(
    game.damage.AttackData self,
    float roll
);

void SetMinimumHealthPercent(float value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "SetMinimumHealthPercent;Float",
    (AttackData_SetMinimumHealthPercent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_SetMinimumHealthPercent(
    game.damage.AttackData self,
    float value
);

WeakHandle<game.Object> GetInstigator() RTTI
WeakHandle<game.Object> GetSource() RTTI
WeakHandle<game.weapon.Object> GetWeapon() RTTI

game.IAttack? GetAttackDefinition() RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "GetAttackDefinition;",
    (AttackData_GetAttackDefinition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IAttack>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_GetAttackDefinition(
    game.damage.AttackData self
);

Vector4 GetAttackPosition() RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "GetAttackPosition;",
    (AttackData_GetAttackPosition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_GetAttackPosition(
    game.damage.AttackData self
);

game.data.AttackType GetAttackType() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct AttackData_GetAttackType(
    game.damage.AttackData self
);

SHitStatusEffect[] GetStatusEffects() RTTI

game.ui.HitType GetHitType() RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "GetHitType;",
    (AttackData_GetHitType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ui.HitType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_GetHitType(
    game.damage.AttackData self
);

float GetWeaponCharge() RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "GetWeaponCharge;",
    (AttackData_GetWeaponCharge x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_GetWeaponCharge(
    game.damage.AttackData self
);

int GetNumRicochetBounces() RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "GetNumRicochetBounces;",
    (AttackData_GetNumRicochetBounces x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_GetNumRicochetBounces(
    game.damage.AttackData self
);

int GetNumAttackSpread() RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "GetNumAttackSpread;",
    (AttackData_GetNumAttackSpread x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_GetNumAttackSpread(
    game.damage.AttackData self
);

float GetVehicleImpactForce() RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "GetVehicleImpactForce;",
    (AttackData_GetVehicleImpactForce x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_GetVehicleImpactForce(
    game.damage.AttackData self
);

float GetAdditionalCritChance() RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "GetAdditionalCritChance;",
    (AttackData_GetAdditionalCritChance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_GetAdditionalCritChance(
    game.damage.AttackData self
);

int GetHitReactionSeverityMin() RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "GetHitReactionSeverityMin;",
    (AttackData_GetHitReactionSeverityMin x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_GetHitReactionSeverityMin(
    game.damage.AttackData self
);

int GetHitReactionSeverityMax() RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "GetHitReactionSeverityMax;",
    (AttackData_GetHitReactionSeverityMax x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_GetHitReactionSeverityMax(
    game.damage.AttackData self
);

float GetAttackTime() RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "GetAttackTime;",
    (AttackData_GetAttackTime x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_GetAttackTime(
    game.damage.AttackData self
);

game.data.TriggerMode GetTriggerMode() RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "GetTriggerMode;",
    (AttackData_GetTriggerMode x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.TriggerMode>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_GetTriggerMode(
    game.damage.AttackData self
);

float GetRandRoll() RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "GetRandRoll;",
    (AttackData_GetRandRoll x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_GetRandRoll(
    game.damage.AttackData self
);

float GetMinimumHealthPercent() RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "GetMinimumHealthPercent;",
    (AttackData_GetMinimumHealthPercent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_GetMinimumHealthPercent(
    game.damage.AttackData self
);

game.data.AttackSubtype GetAttackSubtype() RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "GetAttackSubtype;",
    (AttackData_GetAttackSubtype x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AttackSubtype>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_GetAttackSubtype(
    game.damage.AttackData self
);

bool WasBlocked() RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "WasBlocked;",
    (AttackData_WasBlocked x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_WasBlocked(
    game.damage.AttackData self
);

bool WasBulletBlocked() RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "WasBulletBlocked;",
    (AttackData_WasBulletBlocked x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_WasBulletBlocked(
    game.damage.AttackData self
);

bool WasDeflected() RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "WasDeflected;",
    (AttackData_WasDeflected x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_WasDeflected(
    game.damage.AttackData self
);

bool WasBulletDeflected() RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "WasBulletDeflected;",
    (AttackData_WasBulletDeflected x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_WasBulletDeflected(
    game.damage.AttackData self
);

bool WasDeflectedAny() RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "WasDeflectedAny;",
    (AttackData_WasDeflectedAny x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_WasDeflectedAny(
    game.damage.AttackData self
);

bool DoesAttackWeaponHaveTag(CName tag) RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "DoesAttackWeaponHaveTag;CName",
    (AttackData_DoesAttackWeaponHaveTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_DoesAttackWeaponHaveTag(
    game.damage.AttackData self,
    CName tag
);

void ClearDamage() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "ClearDamage;",
    (AttackData_ClearDamage x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_ClearDamage(
    game.damage.AttackData self
);

void AddStatusEffect(TDBID effect, float stacks) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "AddStatusEffect;TweakDBIDFloat",
    (AttackData_AddStatusEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_AddStatusEffect(
    game.damage.AttackData self,
    TDBID effect,
    float stacks
);

bool HasFlag(hitFlag flag) RTTI

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "HasFlag;hitFlag",
    (AttackData_HasFlag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_HasFlag(
    game.damage.AttackData self,
    hitFlag flag
);

void AddFlag(hitFlag flag, CName sourceName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "AddFlag;hitFlagCName",
    (AttackData_AddFlag x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_AddFlag(
    game.damage.AttackData self,
    hitFlag flag,
    CName sourceName
);

void RemoveFlag(hitFlag flag, CName sourceName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "RemoveFlag;hitFlagCName",
    (AttackData_RemoveFlag x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_RemoveFlag(
    game.damage.AttackData self,
    hitFlag flag,
    CName sourceName
);

void RemoveFlag(hitFlag flag) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedamageAttackData",
    "RemoveFlag;hitFlag",
    (AttackData_RemoveFlag2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_RemoveFlag2(
    game.damage.AttackData self,
    hitFlag flag
);

SHitFlag[] GetFlags() RTTI

static bool IsDismembermentCause(game.data.AttackType attackType) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::IsDismembermentCause;gamedataAttackType",
    (AttackData_IsDismembermentCause x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_IsDismembermentCause(
    game.data.AttackType attackType
);

static bool IsReflect(game.data.AttackType attackType) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::IsReflect;gamedataAttackType",
    (AttackData_IsReflect x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_IsReflect(
    game.data.AttackType attackType
);

static bool CanEffectCriticallyHit(game.damage.AttackData attackData, game.StatsSystem statsSystem) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::CanEffectCriticallyHit;AttackDataStatsSystem",
    (AttackData_CanEffectCriticallyHit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static bool IsDoT(game.data.AttackType attackType) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::IsDoT;gamedataAttackType",
    (AttackData_IsDoT x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_IsDoT(
    game.data.AttackType attackType
);

static bool IsDoT(game.damage.AttackData attackData) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::IsDoT;AttackData",
    (AttackData_IsDoT2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_IsDoT2(
    game.damage.AttackData? attackData
);

static bool IsMelee(game.data.AttackType attackType) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::IsMelee;gamedataAttackType",
    (AttackData_IsMelee x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_IsMelee(
    game.data.AttackType attackType
);

static bool IsPressureWave(game.data.AttackType attackType) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::IsPressureWave;gamedataAttackType",
    (AttackData_IsPressureWave x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_IsPressureWave(
    game.data.AttackType attackType
);

static bool IsEffect(game.data.AttackType attackType) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::IsEffect;gamedataAttackType",
    (AttackData_IsEffect x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_IsEffect(
    game.data.AttackType attackType
);

static bool IsExplosion(game.data.AttackType attackType) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::IsExplosion;gamedataAttackType",
    (AttackData_IsExplosion x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_IsExplosion(
    game.data.AttackType attackType
);

static bool IsQuickMelee(game.data.AttackType attackType) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::IsQuickMelee;gamedataAttackType",
    (AttackData_IsQuickMelee x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_IsQuickMelee(
    game.data.AttackType attackType
);

static bool IsWhip(game.data.AttackType attackType) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::IsWhip;gamedataAttackType",
    (AttackData_IsWhip x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_IsWhip(
    game.data.AttackType attackType
);

static bool CanGrenadeCriticallyHit(game.damage.AttackData attackData, game.StatsSystem statsSystem) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::CanGrenadeCriticallyHit;AttackDataStatsSystem",
    (AttackData_CanGrenadeCriticallyHit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static bool IsHack(game.data.AttackType attackType) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::IsHack;gamedataAttackType",
    (AttackData_IsHack x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_IsHack(
    game.data.AttackType attackType
);

static bool IsRangedOrDirectOrThrown(game.data.AttackType attackType) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::IsRangedOrDirectOrThrown;gamedataAttackType",
    (AttackData_IsRangedOrDirectOrThrown x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_IsRangedOrDirectOrThrown(
    game.data.AttackType attackType
);

static bool IsLightMelee(game.data.AttackType attackType) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::IsLightMelee;gamedataAttackType",
    (AttackData_IsLightMelee x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_IsLightMelee(
    game.data.AttackType attackType
);

static bool IsAreaOfEffect(game.data.AttackType attackType) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::IsAreaOfEffect;gamedataAttackType",
    (AttackData_IsAreaOfEffect x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_IsAreaOfEffect(
    game.data.AttackType attackType
);

static bool IsRangedOrDirect(game.data.AttackType attackType) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::IsRangedOrDirect;gamedataAttackType",
    (AttackData_IsRangedOrDirect x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_IsRangedOrDirect(
    game.data.AttackType attackType
);

static bool IsRangedOnly(game.data.AttackType attackType) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::IsRangedOnly;gamedataAttackType",
    (AttackData_IsRangedOnly x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_IsRangedOnly(
    game.data.AttackType attackType
);

static bool IsPlayerInCombat(game.damage.AttackData attackData) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::IsPlayerInCombat;AttackData",
    (AttackData_IsPlayerInCombat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_IsPlayerInCombat(
    game.damage.AttackData? attackData
);

static bool HasFlag(SHitFlag[] flags, hitFlag flag) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::HasFlag;script_ref<array<SHitFlag>>hitFlag",
    (AttackData_HasFlag2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_HasFlag2(
    SHitFlag[] flags,
    hitFlag flag
);

static bool IsStrongMelee(game.data.AttackType attackType) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::IsStrongMelee;gamedataAttackType",
    (AttackData_IsStrongMelee x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_IsStrongMelee(
    game.data.AttackType attackType
);

static bool IsThrown(game.data.AttackType attackType) staticRTTI global

Generated hook

re.Hooks.Place(
    "gamedamageAttackData",
    "gamedamageAttackData::IsThrown;gamedataAttackType",
    (AttackData_IsThrown x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AttackData_IsThrown(
    game.data.AttackType attackType
);