class game.data

Attack_Record

game.data.Attack_Record

0 properties
33 functions
2 derived classes

Extends game.data.TweakDBRecord IScriptable ISerializable

Derived

game.data.Attack_GameEffect_Record, game.data.Attack_Projectile_Record

Properties

None.

Functions

string UserDataPath() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "UserDataPath",
    (Attack_Record_UserDataPath x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_UserDataPath(
    game.data.Attack_Record self
);

WeakHandle<game.data.DamageType_Record> DamageType() RTTI

game.data.DamageType_Record? DamageTypeHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "DamageTypeHandle",
    (Attack_Record_DamageTypeHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.DamageType_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_DamageTypeHandle(
    game.data.Attack_Record self
);

WeakHandle<game.data.AttackType_Record> AttackType() RTTI

game.data.AttackType_Record? AttackTypeHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "AttackTypeHandle",
    (Attack_Record_AttackTypeHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AttackType_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_AttackTypeHandle(
    game.data.Attack_Record self
);

void StatusEffects(out WeakHandle<game.data.StatusEffectAttackData_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAttack_Record",
    "StatusEffects",
    (Attack_Record_StatusEffects x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_StatusEffects(
    game.data.Attack_Record self,
    WeakHandle<game.data.StatusEffectAttackData_Record>[] outList
);

int GetStatusEffectsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "GetStatusEffectsCount",
    (Attack_Record_GetStatusEffectsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_GetStatusEffectsCount(
    game.data.Attack_Record self
);

WeakHandle<game.data.StatusEffectAttackData_Record> GetStatusEffectsItem(int index) RTTI

game.data.StatusEffectAttackData_Record? GetStatusEffectsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "GetStatusEffectsItemHandle",
    (Attack_Record_GetStatusEffectsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.StatusEffectAttackData_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_GetStatusEffectsItemHandle(
    game.data.Attack_Record self,
    int index
);

bool StatusEffectsContains(WeakHandle<game.data.StatusEffectAttackData_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "StatusEffectsContains",
    (Attack_Record_StatusEffectsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_StatusEffectsContains(
    game.data.Attack_Record self,
    WeakHandle<game.data.StatusEffectAttackData_Record> item
);

List HitFlags() RTTI

int GetHitFlagsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "GetHitFlagsCount",
    (Attack_Record_GetHitFlagsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_GetHitFlagsCount(
    game.data.Attack_Record self
);

string GetHitFlagsItem(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "GetHitFlagsItem",
    (Attack_Record_GetHitFlagsItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_GetHitFlagsItem(
    game.data.Attack_Record self,
    int index
);

bool HitFlagsContains(string item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "HitFlagsContains",
    (Attack_Record_HitFlagsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_HitFlagsContains(
    game.data.Attack_Record self,
    string item
);

void StatModifiers(out WeakHandle<game.data.StatModifier_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAttack_Record",
    "StatModifiers",
    (Attack_Record_StatModifiers x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_StatModifiers(
    game.data.Attack_Record self,
    WeakHandle<game.data.StatModifier_Record>[] outList
);

int GetStatModifiersCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "GetStatModifiersCount",
    (Attack_Record_GetStatModifiersCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_GetStatModifiersCount(
    game.data.Attack_Record self
);

WeakHandle<game.data.StatModifier_Record> GetStatModifiersItem(int index) RTTI

game.data.StatModifier_Record? GetStatModifiersItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "GetStatModifiersItemHandle",
    (Attack_Record_GetStatModifiersItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.StatModifier_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_GetStatModifiersItemHandle(
    game.data.Attack_Record self,
    int index
);

bool StatModifiersContains(WeakHandle<game.data.StatModifier_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "StatModifiersContains",
    (Attack_Record_StatModifiersContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_StatModifiersContains(
    game.data.Attack_Record self,
    WeakHandle<game.data.StatModifier_Record> item
);

void StaminaCost(out WeakHandle<game.data.StatModifier_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataAttack_Record",
    "StaminaCost",
    (Attack_Record_StaminaCost x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_StaminaCost(
    game.data.Attack_Record self,
    WeakHandle<game.data.StatModifier_Record>[] outList
);

int GetStaminaCostCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "GetStaminaCostCount",
    (Attack_Record_GetStaminaCostCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_GetStaminaCostCount(
    game.data.Attack_Record self
);

WeakHandle<game.data.StatModifier_Record> GetStaminaCostItem(int index) RTTI

game.data.StatModifier_Record? GetStaminaCostItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "GetStaminaCostItemHandle",
    (Attack_Record_GetStaminaCostItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.StatModifier_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_GetStaminaCostItemHandle(
    game.data.Attack_Record self,
    int index
);

bool StaminaCostContains(WeakHandle<game.data.StatModifier_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "StaminaCostContains",
    (Attack_Record_StaminaCostContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_StaminaCostContains(
    game.data.Attack_Record self,
    WeakHandle<game.data.StatModifier_Record> item
);

CName ClassName() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "ClassName",
    (Attack_Record_ClassName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_ClassName(
    game.data.Attack_Record self
);

CName AttackName() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "AttackName",
    (Attack_Record_AttackName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_AttackName(
    game.data.Attack_Record self
);

float PlayerIncomingDamageMultiplier() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "PlayerIncomingDamageMultiplier",
    (Attack_Record_PlayerIncomingDamageMultiplier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_PlayerIncomingDamageMultiplier(
    game.data.Attack_Record self
);

float Velocity() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "Velocity",
    (Attack_Record_Velocity x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_Velocity(
    game.data.Attack_Record self
);

float Range() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "Range",
    (Attack_Record_Range x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_Range(
    game.data.Attack_Record self
);

int HitReactionSeverityMin() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "HitReactionSeverityMin",
    (Attack_Record_HitReactionSeverityMin x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_HitReactionSeverityMin(
    game.data.Attack_Record self
);

int HitReactionSeverityMax() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "HitReactionSeverityMax",
    (Attack_Record_HitReactionSeverityMax x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_HitReactionSeverityMax(
    game.data.Attack_Record self
);

float ExplosionDamageVSVehicles() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "ExplosionDamageVSVehicles",
    (Attack_Record_ExplosionDamageVSVehicles x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_ExplosionDamageVSVehicles(
    game.data.Attack_Record self
);

bool UseDefaultAimData() RTTI

Generated hook

re.Hooks.Place(
    "gamedataAttack_Record",
    "UseDefaultAimData",
    (Attack_Record_UseDefaultAimData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Attack_Record_UseDefaultAimData(
    game.data.Attack_Record self
);