class

MonoDisc

18 properties
31 functions

Extends BaseProjectile game.ItemObject game.TimeDilatable game.Object ent.GameEntity ent.Entity IScriptable ISerializable

Properties

Property	Type	Offset
`throwtype`	`ThrowType`	`0x180`	scripted
`targetAcquired`	`bool`	`0x184`	scripted
`player`	`WeakHandle<game.Object>`	`0x188`	scripted
`disc`	`WeakHandle<game.Object>`	`0x198`	scripted
`target`	`WeakHandle<game.Object>`	`0x1A8`	scripted
`blackboard`	`WeakHandle<game.IBlackboard>`	`0x1B8`	scripted
`discSpawnPoint`	`Vector4`	`0x1D0`	scripted
`discPosition`	`Vector4`	`0x1E0`	scripted
`collisionCount`	`int`	`0x1F0`	scripted
`airTime`	`float`	`0x1F4`	scripted
`destroyTimer`	`float`	`0x1F8`	scripted
`returningToPlayer`	`bool`	`0x1FC`	scripted
`catchingPlayer`	`bool`	`0x1FD`	scripted
`discCaught`	`bool`	`0x1FE`	scripted
`discLodgedToSurface`	`bool`	`0x1FF`	scripted
`OnProjectileCaughtCallback`	`red.CallbackObject?`	`0x200`	scripted
`wasNPCHit`	`bool`	`0x210`	scripted
`animationController`	`ent.AnimationControllerComponent?`	`0x218`	scripted

Functions

bool OnRequestComponents(ent.EntityRequestComponentsInterface ri) overrideRTTI

Generated hook

re.Hooks.Place(
    "MonoDisc",
    "OnRequestComponents",
    (MonoDisc_OnRequestComponents x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_OnRequestComponents(
    MonoDisc self,
    ent.EntityRequestComponentsInterface ri
);

bool OnTakeControl(ent.EntityResolveComponentsInterface ri) overrideRTTI

Generated hook

re.Hooks.Place(
    "MonoDisc",
    "OnTakeControl",
    (MonoDisc_OnTakeControl x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_OnTakeControl(
    MonoDisc self,
    ent.EntityResolveComponentsInterface ri
);

bool OnProjectileInitialize(game.projectile.SetUpEvent eventData) overrideRTTI

Generated hook

re.Hooks.Place(
    "MonoDisc",
    "OnProjectileInitialize",
    (MonoDisc_OnProjectileInitialize x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_OnProjectileInitialize(
    MonoDisc self,
    game.projectile.SetUpEvent? eventData
);

void RegisterForProjectileCaught() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MonoDisc",
    "RegisterForProjectileCaught;",
    (MonoDisc_RegisterForProjectileCaught x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_RegisterForProjectileCaught(
    MonoDisc self
);

bool OnShoot(game.projectile.ShootEvent eventData) overrideRTTI

Generated hook

re.Hooks.Place(
    "MonoDisc",
    "OnShoot",
    (MonoDisc_OnShoot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_OnShoot(
    MonoDisc self,
    game.projectile.ShootEvent? eventData
);

bool OnShootTarget(game.projectile.ShootTargetEvent eventData) overrideRTTI

Generated hook

re.Hooks.Place(
    "MonoDisc",
    "OnShootTarget",
    (MonoDisc_OnShootTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_OnShootTarget(
    MonoDisc self,
    game.projectile.ShootTargetEvent? eventData
);

void GeneralShoot(game.projectile.ShootEvent eventData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MonoDisc",
    "GeneralShoot;gameprojectileShootEvent",
    (MonoDisc_GeneralShoot x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_GeneralShoot(
    MonoDisc self,
    game.projectile.ShootEvent? eventData
);

void ResetParameters() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MonoDisc",
    "ResetParameters;",
    (MonoDisc_ResetParameters x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_ResetParameters(
    MonoDisc self
);

void GetThrowType(float chargeParam) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MonoDisc",
    "GetThrowType;Float",
    (MonoDisc_GetThrowType x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_GetThrowType(
    MonoDisc self,
    float chargeParam
);

bool OnProjectileCaught(bool value) RTTI

Generated hook

re.Hooks.Place(
    "MonoDisc",
    "OnProjectileCaught",
    (MonoDisc_OnProjectileCaught x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void LaunchDisc(game.projectile.ShootEvent eventData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MonoDisc",
    "LaunchDisc;gameprojectileShootEvent",
    (MonoDisc_LaunchDisc x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_LaunchDisc(
    MonoDisc self,
    game.projectile.ShootEvent? eventData
);

void NoTargetLaunch(Matrix localToWorld, float startVelocity, float distance, float sideOffset, float height) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MonoDisc",
    "NoTargetLaunch;script_ref<Matrix>FloatFloatFloatFloat",
    (MonoDisc_NoTargetLaunch x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_NoTargetLaunch(
    MonoDisc self,
    Matrix localToWorld,
    float startVelocity,
    float distance,
    float sideOffset,
    float height
);

int GetBlackboardIntVariable(game.bb.ScriptID_Int32 id) RTTI

Generated hook

re.Hooks.Place(
    "MonoDisc",
    "GetBlackboardIntVariable;BlackboardID_Int",
    (MonoDisc_GetBlackboardIntVariable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_GetBlackboardIntVariable(
    MonoDisc self,
    game.bb.ScriptID_Int32 id
);

void UpdateAnimData() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MonoDisc",
    "UpdateAnimData;",
    (MonoDisc_UpdateAnimData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_UpdateAnimData(
    MonoDisc self
);

bool OnTick(game.projectile.TickEvent eventData) RTTI

Generated hook

re.Hooks.Place(
    "MonoDisc",
    "OnTick",
    (MonoDisc_OnTick x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_OnTick(
    MonoDisc self,
    game.projectile.TickEvent? eventData
);

float GetMaxDistance() RTTI

Generated hook

re.Hooks.Place(
    "MonoDisc",
    "GetMaxDistance;",
    (MonoDisc_GetMaxDistance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_GetMaxDistance(
    MonoDisc self
);

bool IsPlayerInKerenzikov() RTTI

Generated hook

re.Hooks.Place(
    "MonoDisc",
    "IsPlayerInKerenzikov;",
    (MonoDisc_IsPlayerInKerenzikov x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_IsPlayerInKerenzikov(
    MonoDisc self
);

float GetPlayerSpeed() RTTI

Generated hook

re.Hooks.Place(
    "MonoDisc",
    "GetPlayerSpeed;",
    (MonoDisc_GetPlayerSpeed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_GetPlayerSpeed(
    MonoDisc self
);

Vector4 GetPlayerPosition() RTTI

Generated hook

re.Hooks.Place(
    "MonoDisc",
    "GetPlayerPosition;",
    (MonoDisc_GetPlayerPosition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_GetPlayerPosition(
    MonoDisc self
);

bool OnCollision(game.projectile.HitEvent eventData) overrideRTTI

Generated hook

re.Hooks.Place(
    "MonoDisc",
    "OnCollision",
    (MonoDisc_OnCollision x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_OnCollision(
    MonoDisc self,
    game.projectile.HitEvent? eventData
);

void LodgeDiscToSurface() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MonoDisc",
    "LodgeDiscToSurface;",
    (MonoDisc_LodgeDiscToSurface x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_LodgeDiscToSurface(
    MonoDisc self
);

void DealDamage(game.projectile.HitEvent eventData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MonoDisc",
    "DealDamage;gameprojectileHitEvent",
    (MonoDisc_DealDamage x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_DealDamage(
    MonoDisc self,
    game.projectile.HitEvent? eventData
);

void SetTargetComponentQuickThrow(ent.IPlacedComponent quickThrowTarget) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MonoDisc",
    "SetTargetComponentQuickThrow;IPlacedComponent",
    (MonoDisc_SetTargetComponentQuickThrow x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_SetTargetComponentQuickThrow(
    MonoDisc self,
    ent.IPlacedComponent? quickThrowTarget
);

void SetTargetComponent(ent.IPlacedComponent target) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MonoDisc",
    "SetTargetComponent;IPlacedComponent",
    (MonoDisc_SetTargetComponent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_SetTargetComponent(
    MonoDisc self,
    ent.IPlacedComponent? target
);

CName GetPlayerTargetComponent() RTTI

Generated hook

re.Hooks.Place(
    "MonoDisc",
    "GetPlayerTargetComponent;",
    (MonoDisc_GetPlayerTargetComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_GetPlayerTargetComponent(
    MonoDisc self
);

void ReturnToPlayer() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MonoDisc",
    "ReturnToPlayer;",
    (MonoDisc_ReturnToPlayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_ReturnToPlayer(
    MonoDisc self
);

void StartCathingPlayer() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MonoDisc",
    "StartCathingPlayer;",
    (MonoDisc_StartCathingPlayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_StartCathingPlayer(
    MonoDisc self
);

bool OnFollowSuccess(game.projectile.FollowEvent eventData) RTTI

Generated hook

re.Hooks.Place(
    "MonoDisc",
    "OnFollowSuccess",
    (MonoDisc_OnFollowSuccess x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_OnFollowSuccess(
    MonoDisc self,
    game.projectile.FollowEvent? eventData
);

void PlayCatchAnimation() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MonoDisc",
    "PlayCatchAnimation;",
    (MonoDisc_PlayCatchAnimation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_PlayCatchAnimation(
    MonoDisc self
);

void SpawnTrailEffects() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MonoDisc",
    "SpawnTrailEffects;",
    (MonoDisc_SpawnTrailEffects x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_SpawnTrailEffects(
    MonoDisc self
);

void SpawnVisualEffect(CName effectName, game.Object disc) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MonoDisc",
    "SpawnVisualEffect;CNameGameObject",
    (MonoDisc_SpawnVisualEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MonoDisc_SpawnVisualEffect(
    MonoDisc self,
    CName effectName,
    game.Object? disc
);