Hello, This is my code:. My code:using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /Fortnite.com/Characters }
using { /UnrealEngine.com/Temporary/SpatialMath }
A Verse-authored creative device that can be placed in a level and spawns a football-like projectile that detects player collisions.
Projectile_Device := class(creative_device):
# @editable allows you to modify this property in the Fortnite editor.
# This property links to a Signal Remote Manager device in your level.
@editable Signal_Remote_Manager : signal_remote_manager_device = signal_remote_manager_device{}
# @editable float properties to control the projectile's behavior.
@editable Proj_Speed : float = 1.5 # How fast the projectile moves.
@editable Proj_Range : float = 10000.0 # How far the projectile will travel before being disposed.
@editable Proj_Collision_Radius : float = 500.0 # The radius around the projectile that will trigger a collision with a player.
# @editable property to select the visual asset for the projectile in the editor.
@editable ProjectileB : creative_prop_asset = DefaultCreativePropAsset
# OnBegin is a function that overrides the base class's OnBegin.
# It runs once when the device is started in a running game.
OnBegin<override>()<suspends>: void =
# Subscribes the SignalRemotePressed function to the PrimarySignalEvent of the linked Signal Remote Manager.
# This means when the primary signal is triggered on the remote, SignalRemotePressed will be executed.
Signal_Remote_Manager.PrimarySignalEvent.Subscribe(SignalRemotePressed)
# This function is called when the primary signal is received from the Signal Remote Manager.
# It takes the agent (the player who triggered the signal) as an argument.
SignalRemotePressed(Agent : agent) : void = {
# Spawns a new concurrent task (using spawn {}) that runs the Proj_Maker_Subscriber function.
# This allows the projectile spawning and movement logic to happen without blocking other game logic.
spawn{ Proj_Maker_Subscriber(Agent) }
}
# This function is responsible for creating and launching the projectile.
# It takes the agent who triggered the launch as an argument.
Proj_Maker_Subscriber(Agent : agent)<suspends> : void = {
# Attempts to get the FortCharacter associated with the triggering agent.
if (Fort_Char := Agent.GetFortCharacter[]) {
# Gets the current world position of the player's character.
Player_Pos := Fort_Char.GetTransform().Translation
# Gets the current view rotation of the player (where they are looking).
Player_View_Rot := Fort_Char.GetViewRotation()
# Calculates a vector representing a short push forward based on the player's view direction.
# GetLocalForward() gets the forward direction from the rotation, and it's multiplied by 400.0 for a short distance.
Player_Push_Dir := Player_View_Rot.GetLocalForward() * 400.0
# Calculates a vector representing the total forward travel distance based on the player's view direction and the Proj_Range.
Player_End_Push_Dir := Player_View_Rot.GetLocalForward() * Proj_Range
# Calculates the initial spawn position of the projectile by adding the short forward push to the player's position.
Spawn_Prop_Position := Player_Pos + Player_Push_Dir
# Calculates the final target position for the projectile by adding the total forward travel distance to the player's position.
Spawn_Prop_Final_Position := Player_Pos + Player_End_Push_Dir
# Attempts to spawn the creative prop asset (ProjectileB) at the calculated Spawn_Prop_Position with no rotation (IdentityRotation()).
# SpawnProp returns an option, so we use (0)? to access the spawned prop if successful.
if (ProjectileProp := SpawnProp(ProjectileB, Spawn_Prop_Position, IdentityRotation())(0)?) {
# Uses a race expression to run two blocks of code concurrently. The first one to complete will cancel the other.
race {
block:
# Moves the spawned projectile to the Spawn_Prop_Final_Position with no rotation over Proj_Speed seconds.
ProjectileProp.MoveTo(Spawn_Prop_Final_Position, IdentityRotation(), Proj_Speed)
# Once the MoveTo is complete (or interrupted), the projectile is disposed of (removed from the world).
ProjectileProp.Dispose()
# Exits this concurrent task.
return
# Runs the Proj_Distance_Check function concurrently to check for collisions.
Proj_Distance_Check(ProjectileProp, Agent)
}
}
}
}
# This function continuously checks for collisions between the projectile and other players.
# It takes the projectile prop and the shooter agent as arguments.
Proj_Distance_Check(ProjectileProp : creative_prop, Shooter : agent)<suspends> : void = {
# Creates an infinite loop that runs until the function is suspended or exited.
loop:
# Pauses the execution of this loop for 0.1 seconds to avoid excessive checking.
Sleep(0.1)
# Iterates through all players currently in the playspace of the projectile.
for (Player : ProjectileProp.GetPlayspace().GetPlayers(),
# Attempts to get the FortCharacter associated with the current player in the loop.
Fort_Char := Player.GetFortCharacter[],
# Gets the agent associated with the current player in the loop.
Agent := agent[Player]) {
# Calculates the distance between the current player's character and the projectile.
Distance_Prop_Player := Distance(Fort_Char.GetTransform().Translation, ProjectileProp.GetTransform().Translation)
# Checks if the distance is less than the defined Proj_Collision_Radius.
if (Distance_Prop_Player < Proj_Collision_Radius) {
# Checks if the colliding agent is NOT the agent who launched the projectile.
if (not Agent = Shooter) {
# Prints a message to the output log indicating a collision.
Print("Football hit player!")
# This is a comment indicating where you could add logic for visual or sound effects upon a hit.
# Optionally trigger some visual effect or sound here
# For example, you could play a sound:
# SoundManager.PlaySoundAtLocation("Football_Hit_Sound", Fort_Char.GetTransform().Translation)
}
}
}
}
My code
- Spawns a projectile (like a football): When triggered by a signal, it creates a prop in the game world.
- Launches the projectile forward: It calculates a direction based on the player’s view and propels the projectile.
- Has adjustable properties: You can set the projectile’s speed, how far it travels (range), and the radius for detecting collisions.
- Detects collisions with players: It constantly checks if the projectile gets within a certain distance of any player.
- Ignores the player who launched it: It won’t trigger a “hit” if the projectile bumps into the player who shot it.
- Prints a message on hit: When the projectile collides with another player, it displays “Football hit player!” in the logs.
- Provides a place for custom hit effects: The code has commented-out sections where you could add things like playing a sound or showing a visual effect when a player is hit.
- Disposes of the projectile: If the projectile reaches its maximum range without hitting anyone, it disappears.
- Triggered by a signal: It uses a
signal_remote_manager_deviceto listen for a signal that starts the whole process.
Now how can I make the projectile also move downwards when thrown like gravity.
Thank you.