Verse API reference page for the fort_item_pickup_interactable_component class | Fortnite Documentation

Place this component onto an entity to allow it to be added to an agent inventory on interaction. The owning entity should have an item_component and a mesh_component. This component expects the interacting agent to have a subentity with an inventory_component.


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

Inheritance Hierarchy

This class is derived from the following hierarchy, starting with component:

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 ==============================================================================
`interactable_component`	Used to handle general interaction.
`basic_interactable_component`	An interactable component with a composable feature set.

Members

This class has both data members and functions.

Data

Data Member Name	Type	Description
`CanceledEvent`	`unknown`	Event fires when an interaction has ended before completing successfully. Sends the formerly interacting agent. interactable_component cannot be canceled, this event is provided for subclasses to fire where appropriate.
`CanInteractMessage`	`?message`	Message shown if CanInteract succeeds.
`CannotInteractMessage`	`?message`	Message shown if CanInteract fails.
`Cooldown`	`?interactable_cooldown`	Cooldowns begin elapsing on successful interactions. A cooldown which applies for all attempts to interact on this component.
`CooldownPerAgent`	`?interactable_cooldown_per_agent`	Cooldowns begin elapsing on successful interactions. A cooldown which applies for future attempts to interact on this component by the agent which succeeded.
`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.
`InteractableDuration`	`?interactable_duration`	An interaction with a duration does not succeed until the duration has elapsed, and success is not guaranteed as it can be canceled while the duration is active.
`InteractingAgents`	`?[]agent`	The agents which are currently interacting with this interactable.
`StartedEvent`	`unknown`	Event fires when a successful interaction starts. Sends the interacting agent. InteractDuration at or below 0 makes this event identical to InteractSucceededEvent.
`SucceededEvent`	`unknown`	Event fires when an interaction has completed successfully. Sends the formerly interacting agent. InteractDuration at or below 0 makes this event identical to InteractStartedEvent.
`SuccessLimit`	`?interactable_success_limit`	Success limits prevent new interactions once the component has been successfully interacted with a specified number of times.
`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
`Cancel`	Attempt to cancel an interaction. Fails if the supplied agent is not currently interacting with the component.
`CanInteract`	Returns whether the specified agent can interact.
`Disable`	Disable interaction with the component. Disabled components do not provide interaction prompts.
`DisableItemInteraction`
`Enable`	Enable interaction with the component.
`EnableItemInteraction`
`GetInteractorInventory`
`GetRemainingCooldownDurationAffectingAgent`	Get the remaining cooldown of the interactable for the supplied agent. This returns the duration left in seconds of either the shared or per agent cooldown, whichever is greater. Returns the same value when called multiple times within a transaction.
`InteractMessage`
`InteractMessage`	Returns an appropriate message to display to players to communicate the current state of the interactable.
`IsEnabled`	Succeeds if the component is enabled, fails if it’s disabled.
`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`
`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.
`OnInteractionSucceeded`
`OnReceive`	Respond to a scene event. Return true to consume the event and halt propagation to the next entity.
`OnRemovingFromScene`
`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`
`OnStarted`	Called from Start if CanInteract pass successfully to start the interaction. Overriding this function will allow you to create a custom interaction behaviour.
`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.
`SignalCancelEvent`	Fires the CanceledEvent event.
`SignalStartEvent`	Fires the StartedEvent event.
`SignalSucceedEvent`	Fires the SucceededEvent event.
`Start`	Attempt to start an interaction. Fails if the agent does not pass the CanInteract function.
`Succeed`	Attempt to succeed at an interaction. Success will also happen automatically after InteractDuration has elapsed after starting an interaction. Fails if the supplied agent is not currently interacting with the component.