Table of Contents

API example use cases

Targeting

Projectile Toolkit provides various targeting algorithms to meet the needs of different scenarios, here are some example use cases:

Prediction

How to use

💡 Note

• using Blobcreate.ProjectileToolkit; in your scripts to be able to call the APIs.

• Trajectory line materials are Built-in RP materials. If you are using SRP, see Explore the demos > In editor to see how to convert.

Targeting

To launch a projectile to hit a target:

1. Add a Collider and a Rigidbody to your prefab if it doesn't have one (you can set Interpolate to Interpolate and set Collision Detection to Continuous Dynamic to get the best result),

2. In your code, instantiate the prefab,

3. Call one of the targeting algorithms to calculate the launch velocity, and apply it using AddForce(...).

The targeting algorithms are all static methods so the integration is very flexible.

Example code

Take VelocityByTime(...) for example, if you want AI units to accurately striking moving objects:

[SerializeField] Rigidbody projectilePrefab;
[SerializeField] Transform launchPoint;
[SerializeField] float timeOfFlight;
...
// In your own method:
var myRigid = Instantiate(projectilePrefab, launchPoint, launchPoint.rotation);
var v = Projectile.VelocityByTime(myRigid.position, predictedPos, timeOfFlight);
myRigid.AddForce(v, ForceMode.VelocityChange);

View Defender.cs for the whole implementation of this (how to calculate predictedPos, etc.).

Additionally, you can add a Simple Explosive component to your prefab, it handles collision events, explosion VFX, explosion force, and damage. Add the following logic below the above lines to make it work properly (in the above example, targetPosition is predictedPos):

myRigid.GetComponent<ProjectileBehaviour>().Launch(targetPosition);

For 2D

In 2D, everything is the same, except that Rigidbody2D does not have ForceMode2D.VelocityChange mode, so we use ForceMode2D.Impulse instead:

myRigid2D.AddForce(myRigid2D.mass * v, ForceMode2D.Impulse);

Trajectory prediction

To predict and render the trajectory of a projectile:

1. Drag and drop the prefab "Trajectory Predictor.prefab" in folder "Blobcreate/Projectile Toolkit/Prefabs" into your scene,

2. In your script, add the following logic:

[SerializeField] TrajectoryPredictor tp;
...
// Update() or your own method
void Update()
{
  // Call Render to update the positions of the line.
  tp.Render(launchPosition, launchVelocity, distanceOrEnd);
}

Or if you want to predict the trajectory of a moving rigidbody:

tp.Render(myRigid.transform.position, myRigid.velocity, distanceOrEnd);

💡 Note

"distanceOrEnd" here is not a typical field, it means that you can either put "distance (float)", or "end (Vector3)" point of the trajectory if known, to control the length of the predicted trajectory line. In other words, to calculate the trajectory to how far.

Explore the demos

Online

Click here to play the online version (WebGL).

In editor

You can explore the demos under the folder "Blobcreate/Projectile Toolkit/Demos".

Some setup is required:

1. Upgrade materials

The materials are Built-in Render Pipeline materials. If you are using Scriptable Render Pipeline, you can convert the materials easily:

• URP, for newer versions: URP 12.0+, for older versions: URP

  (Optional): import native URP unlit materials from "Blobcreate/Projectile Toolkit/Materials/URP Unlit Materials.unitypackage". Double click on it and import, the corresponding materials will be overriden and updated.

• HDRP, for newer versions: HDRP 12.0+, for older versions: HDRP

• In your custom RP, manually replace these materials with the equivalent shaders in your RP.

⚠ Important

If you encounter that the trajectory is not showing, search the following materials in the Project panel and click on them one by one, and the problem should be fixed: "Dash Line", "Slash Line", "SquareParticle". (This is a Unity Editor bug.)

2. Visual setup (optional):

Post-processing: you can create a post-processing volume and assign your profile to it. A profile called "URPPostProcessing" is provided for use in URP.

If your project uses URP but there are rendering problems with demo scenes you can use "PTK-URP-HighQuality" render pipeline asset.

3. Set up layers and physics

(These settings are for the demo scenes, they are not required for your own scenes/projects.)

Back up your layer settings and physics settings, and apply the layer preset "PTKLayers" and physics preset "PTKPhysics" under ".../Demos/Other Assets/Settings". Detailed steps:

1. (At the top right of Unity editor) select "Layers > Edit Layers...",

2. Click the second icon in the top right of the inspector,

3. Click "Save current to..." button to save your current layer settings,

4. Click that second icon again and then choose "PTKLayers" in the pop up window.

Setting up the physics is similar, select "Edit > Project Settings...", select "Physics", click the second icon in the top right, back up your current settings, and apply "PTKPhysics" preset.

💡 Note

If you want to go back to the physics and layer settings of your project, simply apply the settings you've backed up.

Relation

Which scene demonstrates which algorithm? The relation is shown in the table below:

For Trajectory Predictor component, the demo scene is 02.

💡 Note

The script filenames of the classes are class + .cs. You can find them under the folder "Blobcreate/Projectile Toolkit/Demos/Scripts".

(new in 2.0) PEB Trajectory Predictor

PEB Trajectory Predictor has dedicated documentation page: Link

Projectile Toolkit 2.0