class game.data

VehicleDestruction_Record

game.data.VehicleDestruction_Record

0 properties
48 functions

Extends game.data.TweakDBRecord IScriptable ISerializable

Properties

None.

Functions

void Glass(out WeakHandle<game.data.VehicleDestructibleGlass_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataVehicleDestruction_Record",
    "Glass",
    (VehicleDestruction_Record_Glass x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct VehicleDestruction_Record_Glass(
    game.data.VehicleDestruction_Record self,
    WeakHandle<game.data.VehicleDestructibleGlass_Record>[] outList
);

int GetGlassCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "GetGlassCount",
    (VehicleDestruction_Record_GetGlassCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.VehicleDestructibleGlass_Record> GetGlassItem(int index) RTTI

game.data.VehicleDestructibleGlass_Record? GetGlassItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "GetGlassItemHandle",
    (VehicleDestruction_Record_GetGlassItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.VehicleDestructibleGlass_Record>();
    }
);

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

bool GlassContains(WeakHandle<game.data.VehicleDestructibleGlass_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "GlassContains",
    (VehicleDestruction_Record_GlassContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct VehicleDestruction_Record_GlassContains(
    game.data.VehicleDestruction_Record self,
    WeakHandle<game.data.VehicleDestructibleGlass_Record> item
);

void Lights(out WeakHandle<game.data.VehicleDestructibleLight_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataVehicleDestruction_Record",
    "Lights",
    (VehicleDestruction_Record_Lights x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct VehicleDestruction_Record_Lights(
    game.data.VehicleDestruction_Record self,
    WeakHandle<game.data.VehicleDestructibleLight_Record>[] outList
);

int GetLightsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "GetLightsCount",
    (VehicleDestruction_Record_GetLightsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.VehicleDestructibleLight_Record> GetLightsItem(int index) RTTI

game.data.VehicleDestructibleLight_Record? GetLightsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "GetLightsItemHandle",
    (VehicleDestruction_Record_GetLightsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.VehicleDestructibleLight_Record>();
    }
);

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

bool LightsContains(WeakHandle<game.data.VehicleDestructibleLight_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "LightsContains",
    (VehicleDestruction_Record_LightsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct VehicleDestruction_Record_LightsContains(
    game.data.VehicleDestruction_Record self,
    WeakHandle<game.data.VehicleDestructibleLight_Record> item
);

void Wheels(out WeakHandle<game.data.VehicleDestructibleWheel_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataVehicleDestruction_Record",
    "Wheels",
    (VehicleDestruction_Record_Wheels x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct VehicleDestruction_Record_Wheels(
    game.data.VehicleDestruction_Record self,
    WeakHandle<game.data.VehicleDestructibleWheel_Record>[] outList
);

int GetWheelsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "GetWheelsCount",
    (VehicleDestruction_Record_GetWheelsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.VehicleDestructibleWheel_Record> GetWheelsItem(int index) RTTI

game.data.VehicleDestructibleWheel_Record? GetWheelsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "GetWheelsItemHandle",
    (VehicleDestruction_Record_GetWheelsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.VehicleDestructibleWheel_Record>();
    }
);

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

bool WheelsContains(WeakHandle<game.data.VehicleDestructibleWheel_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "WheelsContains",
    (VehicleDestruction_Record_WheelsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct VehicleDestruction_Record_WheelsContains(
    game.data.VehicleDestruction_Record self,
    WeakHandle<game.data.VehicleDestructibleWheel_Record> item
);

void DetachableParts(out WeakHandle<game.data.VehicleDetachablePart_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataVehicleDestruction_Record",
    "DetachableParts",
    (VehicleDestruction_Record_DetachableParts x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct VehicleDestruction_Record_DetachableParts(
    game.data.VehicleDestruction_Record self,
    WeakHandle<game.data.VehicleDetachablePart_Record>[] outList
);

int GetDetachablePartsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "GetDetachablePartsCount",
    (VehicleDestruction_Record_GetDetachablePartsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.VehicleDetachablePart_Record> GetDetachablePartsItem(int index) RTTI

game.data.VehicleDetachablePart_Record? GetDetachablePartsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "GetDetachablePartsItemHandle",
    (VehicleDestruction_Record_GetDetachablePartsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.VehicleDetachablePart_Record>();
    }
);

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

bool DetachablePartsContains(WeakHandle<game.data.VehicleDetachablePart_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "DetachablePartsContains",
    (VehicleDestruction_Record_DetachablePartsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct VehicleDestruction_Record_DetachablePartsContains(
    game.data.VehicleDestruction_Record self,
    WeakHandle<game.data.VehicleDetachablePart_Record> item
);

void PointDampers(out WeakHandle<game.data.VehicleDestructionPointDamper_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataVehicleDestruction_Record",
    "PointDampers",
    (VehicleDestruction_Record_PointDampers x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct VehicleDestruction_Record_PointDampers(
    game.data.VehicleDestruction_Record self,
    WeakHandle<game.data.VehicleDestructionPointDamper_Record>[] outList
);

int GetPointDampersCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "GetPointDampersCount",
    (VehicleDestruction_Record_GetPointDampersCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.VehicleDestructionPointDamper_Record> GetPointDampersItem(int index) RTTI

game.data.VehicleDestructionPointDamper_Record? GetPointDampersItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "GetPointDampersItemHandle",
    (VehicleDestruction_Record_GetPointDampersItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.VehicleDestructionPointDamper_Record>();
    }
);

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

bool PointDampersContains(WeakHandle<game.data.VehicleDestructionPointDamper_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "PointDampersContains",
    (VehicleDestruction_Record_PointDampersContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct VehicleDestruction_Record_PointDampersContains(
    game.data.VehicleDestruction_Record self,
    WeakHandle<game.data.VehicleDestructionPointDamper_Record> item
);

void DeformableParts(out WeakHandle<game.data.VehicleDeformablePart_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataVehicleDestruction_Record",
    "DeformableParts",
    (VehicleDestruction_Record_DeformableParts x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct VehicleDestruction_Record_DeformableParts(
    game.data.VehicleDestruction_Record self,
    WeakHandle<game.data.VehicleDeformablePart_Record>[] outList
);

int GetDeformablePartsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "GetDeformablePartsCount",
    (VehicleDestruction_Record_GetDeformablePartsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.VehicleDeformablePart_Record> GetDeformablePartsItem(int index) RTTI

game.data.VehicleDeformablePart_Record? GetDeformablePartsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "GetDeformablePartsItemHandle",
    (VehicleDestruction_Record_GetDeformablePartsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.VehicleDeformablePart_Record>();
    }
);

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

bool DeformablePartsContains(WeakHandle<game.data.VehicleDeformablePart_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "DeformablePartsContains",
    (VehicleDestruction_Record_DeformablePartsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct VehicleDestruction_Record_DeformablePartsContains(
    game.data.VehicleDestruction_Record self,
    WeakHandle<game.data.VehicleDeformablePart_Record> item
);

void DoorDetachRules(out WeakHandle<game.data.VehicleDoorDetachRule_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataVehicleDestruction_Record",
    "DoorDetachRules",
    (VehicleDestruction_Record_DoorDetachRules x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct VehicleDestruction_Record_DoorDetachRules(
    game.data.VehicleDestruction_Record self,
    WeakHandle<game.data.VehicleDoorDetachRule_Record>[] outList
);

int GetDoorDetachRulesCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "GetDoorDetachRulesCount",
    (VehicleDestruction_Record_GetDoorDetachRulesCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.VehicleDoorDetachRule_Record> GetDoorDetachRulesItem(int index) RTTI

game.data.VehicleDoorDetachRule_Record? GetDoorDetachRulesItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "GetDoorDetachRulesItemHandle",
    (VehicleDestruction_Record_GetDoorDetachRulesItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.VehicleDoorDetachRule_Record>();
    }
);

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

bool DoorDetachRulesContains(WeakHandle<game.data.VehicleDoorDetachRule_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "DoorDetachRulesContains",
    (VehicleDestruction_Record_DoorDetachRulesContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct VehicleDestruction_Record_DoorDetachRulesContains(
    game.data.VehicleDestruction_Record self,
    WeakHandle<game.data.VehicleDoorDetachRule_Record> item
);

red.ResourceReferenceScriptToken DetachedPartExplosionEffect() RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "DetachedPartExplosionEffect",
    (VehicleDestruction_Record_DetachedPartExplosionEffect x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.red.ResourceReferenceScriptToken>();
    }
);

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

Vector3 VehicleDimensions() RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "VehicleDimensions",
    (VehicleDestruction_Record_VehicleDimensions x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector3>();
    }
);

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

Vector3 ChargePortCenter() RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "ChargePortCenter",
    (VehicleDestruction_Record_ChargePortCenter x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector3>();
    }
);

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

Vector3 GridDimensions() RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "GridDimensions",
    (VehicleDestruction_Record_GridDimensions x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector3>();
    }
);

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

Vector3 GridLocalOffset() RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "GridLocalOffset",
    (VehicleDestruction_Record_GridLocalOffset x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector3>();
    }
);

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

float DamageThreshold() RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "DamageThreshold",
    (VehicleDestruction_Record_DamageThreshold x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

float VelocityValueMinDamage() RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "VelocityValueMinDamage",
    (VehicleDestruction_Record_VelocityValueMinDamage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

float DamageExponent() RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "DamageExponent",
    (VehicleDestruction_Record_DamageExponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

float ForcePropagationFalloff() RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "ForcePropagationFalloff",
    (VehicleDestruction_Record_ForcePropagationFalloff x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

float VelocityValueMaxDamage() RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "VelocityValueMaxDamage",
    (VehicleDestruction_Record_VelocityValueMaxDamage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

float ChargePortRadius() RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "ChargePortRadius",
    (VehicleDestruction_Record_ChargePortRadius x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

float OnHitVelocity() RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "OnHitVelocity",
    (VehicleDestruction_Record_OnHitVelocity x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

bool EnableOnHit() RTTI

Generated hook

re.Hooks.Place(
    "gamedataVehicleDestruction_Record",
    "EnableOnHit",
    (VehicleDestruction_Record_EnableOnHit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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