Availability:NoPublish
Title:UKismetSystemLibrary
Crumbs:
Description:Overview of the blueprint system library.

[EXCERPT:CapsuleTraceMulti_NEW]

This node is designed to return multiple hits resulting from a trace (filtered by Trace Channel).

When executed, this node constructs a capsule (from the 'Radius' and 'Half-Height' inputs) and sweeps it along a line (defined by the 'Start' and 'End' inputs). If the capsule hits any objects **(ones that specifically respond to the specified 'Trace Channel')**, then those are recorded and output together in an array (from the 'Out Hits' pin).

By default, the capsule ignores collisions with the containing blueprint (denoted by the 'Ignore Self' input), and you can opt to exclude other specific Actors as well (by utilizing the 'Actors to Ignore' input). Opting to test against complex collision (with the 'Trace Complex' input) can be slow and is more performance intensive (but yields more precise results).

You can easily check if the trace turned up any results by checking the 'Return Value' output (True if anything was hit, False if not). The 'Out Hits' output generates an array of 'HitResult' structs. A 'HitResult' contains fields like the specific Actor hit, the component inside that Actor, the location of the hit, etc. You can get at these individual fields by using a Break node.
[/EXCERPT:CapsuleTraceMulti_NEW]




[EXCERPT:CapsuleTraceMultiForObjects]

This node is designed to return multiple hits resulting from a trace (filtered by Object Type).

When executed, this node constructs a capsule (from the 'Radius' and 'Half-Height' inputs) and sweeps it along a line (defined by the 'Start' and 'End' inputs). If the capsule hits any objects, then those are recorded and output together in an array (from the 'Out Hits' pin).

By default, the capsule ignores collisions with the containing blueprint (denoted by the 'Ignore Self' input), and you can opt to exclude other specific Actors as well (by utilizing the 'Actors to Ignore' input). 

This node is specifically setup to limit your search to certain object types (Pawns, Characters, etc.). To do so, you add the desired types to an array and plug that array into the 'Object Types' input. The results will only contain objects that match these types. Opting to test against complex collision (with the 'Trace Complex' input) can be slow and is more performance intensive (but yields more precise results).

You can easily check if the trace turned up any results by checking the 'Return Value' output (True if anything was hit, False if not). The 'Out Hits' output generates an array of 'HitResult' structs. A 'HitResult' contains fields like the specific Actor hit, the component inside that Actor, the location of the hit, etc. You can get at these individual fields by using a Break node.
[/EXCERPT:CapsuleTraceMultiForObjects]




[EXCERPT:LineTraceMulti_NEW]

This node is designed to return multiple hits resulting from a trace (filtered by Trace Channel).

When executed, this node performs a ray-cast along a line (defined by the 'Start' and 'End' inputs). If the line intersects any object **(one that specifically responds to the specified 'Trace Channel')**, then it is recorded and output in an array (from the 'Out Hits' pin).

By default, the line ignores collisions with the containing blueprint (denoted by the 'Ignore Self' input), and you can opt to exclude other specific Actors as well (by utilizing the 'Actors to Ignore' input). Opting to test against complex collision (with the 'Trace Complex' input) can be slow and is more performance intensive (but yields more precise results).

You can easily check if the trace turned up any results by checking the 'Return Value' output (True if anything was hit, False if not). The 'Out Hits' output generates an array of 'HitResult' structs. A 'HitResult' contains fields like the specific Actor hit, the component inside that Actor, the location of the hit, etc. You can get at these individual fields by using a Break node.
[/EXCERPT:LineTraceMulti_NEW]





[EXCERPT:LineTraceMultiForObjects]

This node is designed to return multiple hits resulting from a trace (filtered by Object Type).

When executed, this node performs a ray-cast along a line (defined by the 'Start' and 'End' inputs). If the line intersects any object, then it is recorded and output in an array (from the 'Out Hits' pin).

By default, the line ignores collisions with the containing blueprint (denoted by the 'Ignore Self' input), and you can opt to exclude other specific Actors as well (by utilizing the 'Actors to Ignore' input). Opting to test against complex collision (with the 'Trace Complex' input) can be slow and is more performance intensive (but yields more precise results).

This node is specifically setup to limit your search to certain object types (Pawns, Characters, etc.). To do so, you add the desired types to an array and plug that array into the 'Object Types' input. The results will only contain objects that match these types.

You can easily check if the trace turned up any results by checking the 'Return Value' output (True if anything was hit, False if not). The 'Out Hits' output generates an array of 'HitResult' structs. A 'HitResult' contains fields like the specific Actor hit, the component inside that Actor, the location of the hit, etc. You can get at these individual fields by using a Break node.
[/EXCERPT:LineTraceMultiForObjects]




[EXCERPT:SphereTraceMulti_NEW]

This node is designed to return multiple hits resulting from a trace (filtered by Trace Channel).

When executed, this node constructs a sphere (from the 'Radius' input) and sweeps it along a line (defined by the 'Start' and 'End' inputs). If the sphere hits any objects **(ones that specifically respond to the specified 'Trace Channel')**, then those are recorded and output together in an array (from the 'Out Hits' pin).

By default, the sphere ignores collisions with the containing blueprint (denoted by the 'Ignore Self' input), and you can opt to exclude other specific Actors as well (by utilizing the 'Actors to Ignore' input). Opting to test against complex collision (with the 'Trace Complex' input) can be slow and is more performance intensive (but yields more precise results).

You can easily check if the trace turned up any results by checking the 'Return Value' output (True if anything was hit, False if not). The 'Out Hits' output generates an array of 'HitResult' structs. A 'HitResult' contains fields like the specific Actor hit, the component inside that Actor, the location of the hit, etc. You can get at these individual fields by using a Break node.
[/EXCERPT:SphereTraceMulti_NEW]




[EXCERPT:SphereTraceMultiForObjects]

This node is designed to return multiple hits resulting from a trace (filtered by Object Type).

When executed, this node constructs a sphere (from the 'Radius' input) and sweeps it along a line (defined by the 'Start' and 'End' inputs). If the sphere hits any objects, then those are recorded and output together in an array (from the 'Out Hits' pin).

By default, the sphere ignores collisions with the containing blueprint (denoted by the 'Ignore Self' input), and you can opt to exclude other specific Actors as well (by utilizing the 'Actors to Ignore' input). Opting to test against complex collision (with the 'Trace Complex' input) can be slow and is more performance intensive (but yields more precise results).

This node is specifically setup to limit your search to certain object types (Pawns, Characters, etc.). To do so, you add the desired types to an array and plug that array into the 'Object Types' input. The results will only contain objects that match these types.

You can easily check if the trace turned up any results by checking the 'Return Value' output (True if anything was hit, False if not). The 'Out Hits' output generates an array of 'HitResult' structs. A 'HitResult' contains fields like the specific Actor hit, the component inside that Actor, the location of the hit, etc. You can get at these individual fields by using a Break node.
[/EXCERPT:SphereTraceMultiForObjects]




[EXCERPT:CapsuleTraceSingle_NEW]

This node is designed to return a single hit resulting from a trace (filtered by Trace Channel).

When executed, this node constructs a capsule (from the 'Radius' and 'Half-Height' inputs) and sweeps it along a line (defined by the 'Start' and 'End' inputs). If the capsule hits an object **(one that specifically responds to the specified 'Trace Channel')**, then it is output via the 'Out Hit' pin.

By default, the capsule ignores collisions with the containing blueprint (denoted by the 'Ignore Self' input), and you can opt to exclude other specific Actors as well (by utilizing the 'Actors to Ignore' input). Opting to test agaisnt complex collision (with the 'Trace Complex' input) can be slow and is more performance intensive (but yields more precise results).

You can easily check if the trace turned up a hit by checking the 'Return Value' output (True if anything was hit, False if not). The 'Out Hit' output is a 'HitResult' struct. A 'HitResult' contains fields like the specific Actor hit, the component inside that Actor, the location of the hit, etc. You can get at these individual fields by using a Break node.
[/EXCERPT:CapsuleTraceSingle_NEW]




[EXCERPT:CapsuleTraceSingleForObjects]

This node is designed to return a single hit resulting from a trace (filtered by Object Type).

When executed, this node constructs a capsule (from the 'Radius' and 'Half-Height' inputs) and sweeps it along a line (defined by the 'Start' and 'End' inputs). If the capsule hits an object, then it is output via the 'Out Hit' pin.

By default, the capsule ignores collisions with the containing blueprint (denoted by the 'Ignore Self' input), and you can opt to exclude other specific Actors as well (by utilizing the 'Actors to Ignore' input). Opting to test against complex collision (with the 'Trace Complex' input) can be slow and is more performance intensive (but yields more precise results).

This node is specifically setup to limit your search to certain object types (Pawns, Characters, etc.). To do so, you add the desired types to an array and plug that array into the 'Object Types' input. The results will be an object that matches one of these types.

You can easily check if the trace turned up a hit by checking the 'Return Value' output (True if anything was hit, False if not). The 'Out Hit' output is a 'HitResult' struct. A 'HitResult' contains fields like the specific Actor hit, the component inside that Actor, the location of the hit, etc. You can get at these individual fields by using a Break node.
[/EXCERPT:CapsuleTraceSingleForObjects]




[EXCERPT:LineTraceSingle_NEW]

This node is designed to return a single hit resulting from a trace (filtered by Trace Channel).

When executed, this node performs a ray-cast along a line (defined by the 'Start' and 'End' inputs). If the line intersects any object **(one that specifically responds to the specified 'Trace Channel')**, then it is output via the 'Out Hit' pin.

By default, the line ignores collisions with the containing blueprint (denoted by the 'Ignore Self' input), and you can opt to exclude other specific Actors as well (by utilizing the 'Actors to Ignore' input). Opting to test against complex collision (with the 'Trace Complex' input) can be slow and is more performance intensive (but yields more precise results).

You can easily check if the trace turned up a hit by checking the 'Return Value' output (True if anything was hit, False if not). The 'Out Hit' output is a 'HitResult' struct. A 'HitResult' contains fields like the specific Actor hit, the component inside that Actor, the location of the hit, etc. You can get at these individual fields by using a Break node.
[/EXCERPT:LineTraceSingle_NEW]




[EXCERPT:LineTraceSingleForObjects]

This node is designed to return a single hit resulting from a trace (filtered by Object Type).

When executed, this node performs a ray-cast along a line (defined by the 'Start' and 'End' inputs). If the line intersects any object, then it is output via the 'Out Hit' pin.

By default, the line ignores collisions with the containing blueprint (denoted by the 'Ignore Self' input), and you can opt to exclude other specific Actors as well (by utilizing the 'Actors to Ignore' input). Opting to test against complex collision (with the 'Trace Complex' input) can be slow and is more performance intensive (but yields more precise results).

This node is specifically setup to limit your search to certain object types (Pawns, Characters, etc.). To do so, you add the desired types to an array and plug that array into the 'Object Types' input. The results will only contain objects that match these types.

You can easily check if the trace turned up a hit by checking the 'Return Value' output (True if anything was hit, False if not). The 'Out Hit' output is a 'HitResult' struct. A 'HitResult' contains fields like the specific Actor hit, the component inside that Actor, the location of the hit, etc. You can get at these individual fields by using a Break node.
[/EXCERPT:LineTraceSingleForObjects]




[EXCERPT:SphereTraceSingle_NEW]

This node is designed to return a single hit resulting from a trace (filtered by Trace Channel).

When executed, this node constructs a sphere (from the 'Radius' input) and sweeps it along a line (defined by the 'Start' and 'End' inputs). If the sphere hits an object **(one that specifically responds to the specified 'Trace Channel')**, then it is output via the 'Out Hit' pin.

By default, the sphere ignores collisions with the containing blueprint (denoted by the 'Ignore Self' input), and you can opt to exclude other specific Actors as well (by utilizing the 'Actors to Ignore' input). Opting to test against complex collision (with the 'Trace Complex' input) can be slow and is more performance intensive (but yields more precise results).

You can easily check if the trace turned up a hit by checking the 'Return Value' output (True if anything was hit, False if not). The 'Out Hit' output is a 'HitResult' struct. A 'HitResult' contains fields like the specific Actor hit, the component inside that Actor, the location of the hit, etc. You can get at these individual fields by using a Break node.
[/EXCERPT:SphereTraceSingle_NEW]




[EXCERPT:SphereTraceSingleForObjects]

This node is designed to return a single hit resulting from a trace (filtered by Object Type).

When executed, this node constructs a sphere (from the 'Radius' input) and sweeps it along a line (defined by the 'Start' and 'End' inputs). If the sphere hits an object, then it is output via the 'Out Hit' pin.

By default, the sphere ignores collisions with the containing blueprint (denoted by the 'Ignore Self' input), and you can opt to exclude other specific Actors as well (by utilizing the 'Actors to Ignore' input). Opting to test against complex collision (with the 'Trace Complex' input) can be slow and is more performance intensive (but yields more precise results).

This node is specifically setup to limit your search to certain object types (Pawns, Characters, etc.). To do so, you add the desired types to an array and plug that array into the 'Object Types' input. The results will be an object that matches one of these types.

You can easily check if the trace turned up a hit by checking the 'Return Value' output (True if anything was hit, False if not). The 'Out Hit' output is a 'HitResult' struct. A 'HitResult' contains fields like the specific Actor hit, the component inside that Actor, the location of the hit, etc. You can get at these individual fields by using a Break node.
[/EXCERPT:SphereTraceSingleForObjects]