Verse API reference page for the telekineticon_component class | Fortnite Documentation


Verse `using` statement	`using { /Fortnite.com/Items }`

Inheritance Hierarchy

This class is derived from component.

Name Description

Name	Description
`component`	Base class for authoring logic and data in the SceneGraph. Using components you can author re-usable building blocks of logic and data which can then be added to entities in the scene. Components are a very low level building block which can be used in many ways. For example: Exposing engine level concepts like mesh or sound Adding gameplay capabilities like damage or interaction Storing an inventory for a character in the game As components are generic there is no specific way that they must be used. It is up to the needs of your experience if you use one big game component or if you break up logic into many small components. Classes deriving from component must also specify `<final_super>` to be added to entities. This ensures the class will always derive directly from `component`. Further subclassing of the initial derived component is allowed and does not require specifying `<final_super>` on the derived classes. Only one instance of a component from each subclass group can be added to an entity at a time. For example, given this group of components, only one light_component can exist on a single entity. To create multiple lights you should use multiple entities. light_component := class(component){} capsule_light_component := class(light_component){} directional_light_component := class(light_component){} spot_light_component := class(light_component){} sphere_light_component := class(light_component){} rect_light_component := class(light_component){} ============================================================================== Component Lifetime Components move through a series of lifetime functions as they are added to entities, added to the scene, and begin running in the simulation. Components should override these methods to perform setup and run their simulation. As a component shuts down it will then move through shutdown version of these functions, giving users the opportunity to clean up any retained state on the component before it is disposed . Lifetime Methods: OnAddedToScene OnBeginSimulation -> OnSimulate OnEndSimulation OnRemovingFromScene ==============================================================================

component

Base class for authoring logic and data in the SceneGraph. Using components you can author re-usable building blocks of logic and data which can then be added to entities in the scene.

Components are a very low level building block which can be used in many ways. For example:

Exposing engine level concepts like mesh or sound
Adding gameplay capabilities like damage or interaction
Storing an inventory for a character in the game

As components are generic there is no specific way that they must be used. It is up to the needs of your experience if you use one big game component or if you break up logic into many small components.

Classes deriving from component must also specify <final_super> to be added to entities. This ensures the class will always derive directly from component. Further subclassing of the initial derived component is allowed and does not require specifying <final_super> on the derived classes.

Only one instance of a component from each subclass group can be added to an entity at a time. For example, given this group of components, only one light_component can exist on a single entity. To create multiple lights you should use multiple entities.

light_component := class(component){} capsule_light_component := class(light_component){} directional_light_component := class(light_component){} spot_light_component := class(light_component){} sphere_light_component := class(light_component){} rect_light_component := class(light_component){}

============================================================================== Component Lifetime

Components move through a series of lifetime functions as they are added to entities, added to the scene, and begin running in the simulation. Components should override these methods to perform setup and run their simulation.

As a component shuts down it will then move through shutdown version of these functions, giving users the opportunity to clean up any retained state on the component before it is disposed . Lifetime Methods: OnAddedToScene OnBeginSimulation -> OnSimulate OnEndSimulation OnRemovingFromScene ==============================================================================

Members

This class has both data members and functions.

Data

Data Member Name	Type	Description
`BreakDistance`	`?float`	The hold breaks when an applied force pushes the object past this distance, in cm, from its hold position. Larger values will allow the object to be pushed around and spring back to its hold position. If `0.0`, `NaN`, or a negative value is provided, any physical interaction will cause the object to be dropped. If `Inf` is provided, the hold on the object cannot be broken.
`BreakHoldPropEvent`	`listenable(payload)`	Called when the hold on a grabbed object is broken by forces being applied to it. Provides the `creative_prop` that is no longer being grabbed.
`CurrentHoldDistance`	`??float`	The current distance, in cm, from the grabbing agent to the physical prop, along the agent`s forward vector. If false, no physical prop is currently being held. If set to false and a prop is being held, the prop is dropped. If` 0.0`,` NaN`, or a negative value is provided, the object is held at a distance of` 0.0 `cm. If` Inf` is provided, the object is held at a distance as far as can be supported.
`DropPropEvent`	`listenable(payload)`	Called when a grabbed object is dropped. Provides the dropped `creative_prop`.
`Entity`	`entity`	The parent entity of this component. Components must have a parent entity pointer provided when being constructed. Components cannot be moved between parents.
`GrabPropEvent`	`listenable(payload)`	Called when an object is grabbed. Provides the held `creative_prop`.
`GrabRange`	`?float`	The distance, in cm, objects can be grabbed. If `0.0`, `NaN`, or a negative value is provided, there is no range. If `Inf` is provided, any object in the playspace can be affected.
`HoldOrientationType`	`?telekineticon_hold_orientation`	Determines the object`s rotation when grabbed.
`HoldPointType`	`?telekineticon_hold_point`	Determines where on the object the object is grabbed.
`HoldStiffness`	`?float`	The strength of the acceleration, in cm/second^2, that holds the physical prop. With a 1kg prop - ~`1.0` would allow the object to be dragged on the ground when the player moves. ~`10.0` causes the object to be lifted off the ground when pointing upwards, but up to a distance. ~`100.0` holds the object with some wobble. ~`1000.0` stiffly holds the object with very little wobble If `0.0`, `NaN`, or a negative value is provided, the value is clamped to `0.0`. If `Inf` is provided, the hold is rigid and forces do not affect the object being held.
`StartingGrabDistance`	`??float`	The distance in front of the grabbing agent, in cm, the physical prop is held, along the agent`s forward vector. If false, the object stays where it was grabbed relative to the agent`s position. If `0.0`, `NaN`, or a negative value is provided, the object is held at a distance of `0.0` cm. If `Inf` is provided, the object is held at a distance as far as can be supported.
`TickEvents`	`?tick_events`	Set callbacks to `TickEvents.PrePhysics` and `TickEvents.PostPhysics` to receive per-frame updates before and after physics is updated on your object.

Functions

Function Name	Description
`Drop`	If the item has a grabbed object, drop it. Fails if no object is being grabbed.
`GetHeldProp`	Get the current object being grabbed. Fails if no object is being grabbed.
`IsInScene`	Succeeds if the component is currently in the scene. After `OnAddedToScene` is called this call succeeds. After `OnRemovingFromScene` is called this call fails.
`IsSimulating`	Succeeds if the component is currently simulating. After `OnBeginSimulation` is called this call succeeds. After `OnEndSimulation` is called this call fails.
`OnAddedToScene`	Called when the component is added to the scene by parenting it under the simulation entity or another entity already in the scene. Querying for components in the scene is valid after this phase completes.
`OnBeginSimulation`	Called when the component begins simulating within the scene. Use this to set up TickEvent callbacks or other setup that must be guaranteed to complete immediately. `OnAddedToScene` is guaranteed to run before `OnBeginSimulation`.
`OnEndSimulation`	Called when the component ends simulation within the scene. Simulation ends on a component when the experience resets, the parent entity is removed from the scene. Cached TickEvents cancelables should be canceled in `OnEndSimulation`. `OnSimulate` task will be canceled before `OnEndSimulation` is called. `OnEndSimulation` is only called on components that have already had `OnBeginSimulation` called.
`OnReceive`	Respond to a scene event. Return true to consume the event and halt propagation to the next entity.
`OnRemovingFromScene`	Called when the component is about to be removed from the scene. Components are removed from a scene when the parent entity is removed from the scene. `OnRemovingFromScene` is only called on components that have already had `OnAddedToScene` called.
`OnSimulate`	Called when the component begins simulating within the scene. Use this to add asynchronous/suspends update logic for a component. `OnBeginSimulation` is guaranteed to run before `OnSimulate`. `OnSimulate` will be cancelled before `OnEndSimulation`
`RemoveFromEntity`	Removes the component from the entity. Removed components are removed from the scene and can only be added back to the same entity. Flows through `OnEndSimulation`-> `OnRemovingFromScene`.
`SendDown`	Send a scene event to this component, invoking OnReceive. Returns true if any participant consumed the event.