class game.projectile

Component

game.projectile.Component

11 properties
30 functions

Extends ent.IPlacedComponent ent.IComponent IScriptable ISerializable

Properties

Property	Type	Offset
`onCollisionAction`	`game.projectile.OnCollisionAction`	`0x7AC`
`useSweepCollision`	`bool`	`0x7B0`
`collisionsFilterClosest`	`bool`	`0x7BC`
`sweepCollisionRadius`	`float`	`0x7B4`
`rotationOffset`	`Quaternion`	`0x8A0`
`deriveOwnerVelocity`	`bool`	`0x7A9`
`derivedVelocityParams`	`game.projectile.VelocityParams`	`0x7D0`
`filterData`	`physics.FilterData?`	`0x800`
`queryPreset`	`physics.QueryPreset`	`0x810`
`explosionPreviewTime`	`float`	`0x890`
`gameEffectRef`	`game.EffectRef`	`0x820`

Functions

void AddParabolic(game.projectile.ParabolicTrajectoryParams paramss) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "AddParabolic",
    (Component_AddParabolic x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_AddParabolic(
    game.projectile.Component self,
    game.projectile.ParabolicTrajectoryParams? paramss
);

void AddFollow(game.projectile.FollowTrajectoryParams paramss) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "AddFollow",
    (Component_AddFollow x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_AddFollow(
    game.projectile.Component self,
    game.projectile.FollowTrajectoryParams? paramss
);

void AddFollowCurve(game.projectile.FollowCurveTrajectoryParams paramss) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "AddFollowCurve",
    (Component_AddFollowCurve x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_AddFollowCurve(
    game.projectile.Component self,
    game.projectile.FollowCurveTrajectoryParams? paramss
);

void AddAccelerateTowards(game.projectile.AccelerateTowardsTrajectoryParams paramss) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "AddAccelerateTowards",
    (Component_AddAccelerateTowards x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_AddAccelerateTowards(
    game.projectile.Component self,
    game.projectile.AccelerateTowardsTrajectoryParams? paramss
);

void AddLinear(game.projectile.LinearTrajectoryParams paramss) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "AddLinear",
    (Component_AddLinear x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_AddLinear(
    game.projectile.Component self,
    game.projectile.LinearTrajectoryParams? paramss
);

void Slide(game.projectile.SlideTrajectoryParams paramss) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "Slide",
    (Component_Slide x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_Slide(
    game.projectile.Component self,
    game.projectile.SlideTrajectoryParams? paramss
);

void SetSpiral(game.projectile.SpiralParams paramss) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "SetSpiral",
    (Component_SetSpiral x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetSpiral(
    game.projectile.Component self,
    game.projectile.SpiralParams? paramss
);

Vector4 GetPrintVelocity() RTTI

Generated hook

re.Hooks.Place(
    "gameprojectileComponent",
    "GetPrintVelocity",
    (Component_GetPrintVelocity x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_GetPrintVelocity(
    game.projectile.Component self
);

void SetWasTrajectoryStopped(bool wasStopped) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "SetWasTrajectoryStopped",
    (Component_SetWasTrajectoryStopped x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetWasTrajectoryStopped(
    game.projectile.Component self,
    bool wasStopped
);

void SetDesiredTransform(Transform transform) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "SetDesiredTransform",
    (Component_SetDesiredTransform x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetDesiredTransform(
    game.projectile.Component self,
    Transform transform
);

void SetEnergyLossFactor(float energyLossFactor, float puppetEnergyLossFactor) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "SetEnergyLossFactor",
    (Component_SetEnergyLossFactor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetEnergyLossFactor(
    game.projectile.Component self,
    float energyLossFactor,
    float puppetEnergyLossFactor
);

void ClearTrajectories() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "ClearTrajectories",
    (Component_ClearTrajectories x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_ClearTrajectories(
    game.projectile.Component self
);

bool IsTrajectoryEmpty() RTTI

Generated hook

re.Hooks.Place(
    "gameprojectileComponent",
    "IsTrajectoryEmpty",
    (Component_IsTrajectoryEmpty x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_IsTrajectoryEmpty(
    game.projectile.Component self
);

void AddIgnoredEntity(ent.EntityID entityID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "AddIgnoredEntity",
    (Component_AddIgnoredEntity x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_AddIgnoredEntity(
    game.projectile.Component self,
    ent.EntityID entityID
);

void RemoveIgnoredEntity(ent.EntityID entityID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "RemoveIgnoredEntity",
    (Component_RemoveIgnoredEntity x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_RemoveIgnoredEntity(
    game.projectile.Component self,
    ent.EntityID entityID
);

void ClearIgnoredEntities() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "ClearIgnoredEntities",
    (Component_ClearIgnoredEntities x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_ClearIgnoredEntities(
    game.projectile.Component self
);

void SetExplosionVisualRadius(float explosionRadius) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "SetExplosionVisualRadius",
    (Component_SetExplosionVisualRadius x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetExplosionVisualRadius(
    game.projectile.Component self,
    float explosionRadius
);

void SetOnCollisionAction(game.projectile.OnCollisionAction action) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "SetOnCollisionAction",
    (Component_SetOnCollisionAction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetOnCollisionAction(
    game.projectile.Component self,
    game.projectile.OnCollisionAction action
);

game.EffectInstance? GetGameEffectInstance() RTTI

Generated hook

re.Hooks.Place(
    "gameprojectileComponent",
    "GetGameEffectInstance",
    (Component_GetGameEffectInstance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameEffectInstance>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_GetGameEffectInstance(
    game.projectile.Component self
);

void SpawnTrailVFX() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "SpawnTrailVFX",
    (Component_SpawnTrailVFX x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SpawnTrailVFX(
    game.projectile.Component self
);

CName GetTrailVFXName() RTTI

Generated hook

re.Hooks.Place(
    "gameprojectileComponent",
    "GetTrailVFXName",
    (Component_GetTrailVFXName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_GetTrailVFXName(
    game.projectile.Component self
);

float GetTrailVFXScale() RTTI

Generated hook

re.Hooks.Place(
    "gameprojectileComponent",
    "GetTrailVFXScale",
    (Component_GetTrailVFXScale x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_GetTrailVFXScale(
    game.projectile.Component self
);

void ToggleAxisRotation(bool enabled) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "ToggleAxisRotation",
    (Component_ToggleAxisRotation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_ToggleAxisRotation(
    game.projectile.Component self,
    bool enabled
);

void AddAxisRotation(Vector4 axis, float value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "AddAxisRotation",
    (Component_AddAxisRotation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_AddAxisRotation(
    game.projectile.Component self,
    Vector4 axis,
    float value
);

void LockOrientation(bool enable) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "LockOrientation",
    (Component_LockOrientation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_LockOrientation(
    game.projectile.Component self,
    bool enable
);

void SetCollisionEvaluator(game.projectile.ScriptCollisionEvaluator collisionEvaluator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "SetCollisionEvaluator",
    (Component_SetCollisionEvaluator x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetCollisionEvaluator(
    game.projectile.Component self,
    game.projectile.ScriptCollisionEvaluator? collisionEvaluator
);

void SetDeactivationDepth(float depth) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "SetDeactivationDepth",
    (Component_SetDeactivationDepth x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetDeactivationDepth(
    game.projectile.Component self,
    float depth
);

void SetCollisionCooldown(float cooldown) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "SetCollisionCooldown",
    (Component_SetCollisionCooldown x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_SetCollisionCooldown(
    game.projectile.Component self,
    float cooldown
);

WeakHandle<game.Object> GetProjectileOwner() RTTI

void LogDebugVariable(CName key, string value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameprojectileComponent",
    "LogDebugVariable",
    (Component_LogDebugVariable x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Component_LogDebugVariable(
    game.projectile.Component self,
    CName key,
    string value
);