Hello there, I am going to teach you how to create a homing missile projectile that will attack

and hit certainly the targets that you designate as enemies or as destructible targetable objects.

Before proceeding onto the tutorial, it is important to let you know that this will work

certainly on version 4.7. Therefore, this method has not been tested in older versions,

meaning it is at your own risk that you experiment this on older versions. You might wind

up with different or even unwanted results. You have been warned.

1. To start this tutorial off, it is imperative that you create a new project using the First

Person Template mode in the project browser. Name it and save it whatever and

wherever you want, I am naming my project RocketProject.

2. Now that you have created a new project and saved it, proceed onto the content

browser and select the blueprints folder. You will see a blueprint named

FirstPersonProjectile. Right click and create a duplicate of that blueprint and rename it

RocketProjectile.

3. Open the newly created blueprint and youll see this:

SELECT ALL BLUEPRINTS AND DELETE EVERYTHING. We wont need any of this

4. Now that we deleted the entire node network, switch to the viewport mode of the

projectile and select it in the component panel. We will now proceed to modify some

values of the projectile.

5. In the details panel, we will modify the projectile gravity scale value to 0 so as the

projectile is not affected by gravity. Change the value of initial speed to 2000.0 so as

when fired, the projectile will start moving slow and gain speed over time. You can leave

bounce on or off as well, since the projectile will be exploding anyways.

6. Now click on the add components button, and search for RadialForce. Click on it and you

should have this on your screen

7. Rename the RadialForce component into ExplosionForce:

8. Now with ExplosionForce selected, proceed to the details tab and modify the values of

Radius and Impulse Strength to 300.0 and 500000.0 respectively. Compile and save the

blueprint.

9. Switch to the event graph, and we will now add explosion to the projectile. Start by

selecting the collision component in the component tab.

10. In the detail panel, add a node called OnComponentHit. A new node with the same name

should appear. Drag from the white arrow to add the DoOnce executable action. You

should have something like this:

11. Select ExplosionForce from the variable tab, drag and drop it to the event graph

12. Drag from the endpoint of the ExplosionForce and add the FireImpulse action. Proceed to

connect it with the DoOnce node like so:

13. From the ExplosionForce node, drag once again from the endpoint and attach a

GetWorldLocation node. Then drag from the FireImpulse endpoint and add a

SpawnEmitterLocation (This is the particle effect that will have the projectile when fired).

Attach the GetWorldLocation node to the location point of the SpawnEmitterLocation. It

should look like this:

14. Now from the SpawnEmitterLocation, there is a blue point with a drop box menu where it

says Emitter Template. Proceed to select the Explosion effect like so:

15. From the endpoint of the SpawnEmitter, add the action DestroyActor since we dont want

the projectile to remain after the explosion or impact. If for some reason, you cant get

DestroyActor on the available actions, uncheck Content Sensitive from the search box.

16. Select the entire blueprint collection so far, right click and type: add comment to

selection and add this comment when prompted: Explosion on Contact like so:

17. Compile and save the blueprint so far. Exit the event graph and into the main interface. Go

to the content Browser and find the First Person Character blueprint. Open its event graph.

18. Scroll over to the SpawnActorFirstPersonProjectile node. Under class, make sure to

change the FirstPersonProjectile to our newly created RocketProjectile. Make sure to

compile and save it afterwards. Exit the event graph.

19. Now we play test our game and see if it spawns our blueprint projectile instead of the

default one when fired. Make sure you can send the boxes flying when hit and the

explosion effect plays when the projectiles impact on any surface. If any of those, or both

do not happen, STOP AT THIS POINT and review the steps again up to this point. Make

sure it works before proceeding to the next part.

20. Open once again the RocketProjectile blueprint and go into the event graph, we are going

to add a CustomEvent node. Rename the node as Homing Missile.

21. Select the Homing Missile node. Under Inputs, we will add a new input called TargetToHit.

We will change that to static mesh actor. From the blue endpoint arrow of the node, drag

it and add the function IsValid.

22. From the white arrow endpoint of the Homing Missile node, drag it and add the action

Branch. From there, connect the values (red arrow) of the IsValid function to the

condition Arrow like so:

23. From the variable tab, drag the Projectile to the event graph, similarly like we did on step

11 with ExplosionForce, but this time we will do it with Projectile.

24. Drag the arrow endpoint and add the action Set Homing Target Component.

25. Go back to the Homing Missile, drag from the blue arrow endpoint and add the node Get

Static Mesh Component. Draw from the Branch TRUE (NOT FALSE) white arrow endpoint

and connect to the SET node. Connect the Static mesh component endpoint to the

Homing Target Component begin point like so:

26. We will now proceed to set a Boolean confirming that the projectile is a Homing

Projectile. Drag from the projectile node once again and add the Boolean

SetIsHomingProjectile. Check on Is Homing Projectile and connect both SETs like so:

27. Afterwards, we drag from the projectile node once again, and add the node

SetHomingAccelerationMagnitude. From there, change the value of the homing

acceleration Magnitude value to 25000. This is a high number, but it is high so it can

actually track accurate enough the targets. Then connect SetIsHomingProjectile to

SetHomingAccelerationMagnitude like so:

28. Proceed and group the newly created node network and add the following commentary

Set Homing Missile (like in step16). Compile and save.

29. Go back once again to the FirstPersonCharacter blueprint outside in the content browser

and we will set the target to any object in the level for now (since the level is empty). For

that, right click and add RightMouseButton event in the event graph.

30. Drag from the pressed arrow and add the LineTraceForObjects

31. We now need to determine what kind of object will our homing missile can hit. It is

important to know that this step is crucial for this whole thing to work. It can be actors,

meshes, cameras, you name it. For now we will add it so it hits physic objects and this is

how we proceed on this. Under variables, we will create a new variable and we will name

it ObjectsToTarget.

32. Afterwards, go into the details tab and set the variable type to EObjectTypeQuery. Add an

array. Then, set the value so it only targets PhysicsBody.

Drag the ObjectToTarget variable into the event graph, set it as a GET variable and

connect it to object types in the LineTraceForObjects node.

33. Now drag the FirstPersonCamera from the Component tab and into the event graph.

Then drag from the endpoint to add the GetWorldLocation node and connect it to the

start begin point of the LineTraceForObjects node. Drag once again from the endpoint of

FirstPersonCamera and add GetForwardVector (as in the projectile will follow a vector

when it has chosen a target). In order for the vector to work, you need to multiply it with

a Float, so add a Float* (that means multiplier float) and change the value to 5000.0 like

so:

34. Drag from the endpoint of the Float* to add the Vector+Vector node. Now, reconnect

both Begin points to the Float*, and then drag the superior begin point and connect it to

the return value endpoint of the GetWorldLocation. Afterwards, connect the endpoint of

the Vector+Vector node into the end begin point of the LineTraceForObjects like so:

35. Going forward, drag from the Out Hit endpoint and proceed to create a BreakHitResult

node. Then drag from the return value and place another Branch.

36. Drag from the True endpoint of the Branch node and place CastToStaticMeshActor node.

From this new node, drag from the object begin point and connect it to the Hit Actor

endpoint of the BreakHitResult.

37. Create a new variable called HomingTarget, set it as a static mesh actor, but do not add

an array like we did on step 32. Then Drag it as a GET variable to the event graph.

38. Drag from homing target and add an IsValid node (the one with the ? in it). Then drag

from CastStaticMeshActor endpoint to the Exec begin point of the IsValid node

39. Drag once again from the HomingTarget node and add the SetRenderCustomDepth node

(This is going to be the outline of the object we are going to target). Then drag from the

IsNotValid endpoint to add a SetHomingTarget node, then join the As Static Mesh Actor

from the CastToStaticMeshActor node all the way to the SetHomingTargets Homing

target begin point and finally connect both IsValid endpoint to the

SetRenderCustomDepth begin point like so:

40. Drag from the blue endpoint of the SetHomingTarget and add another

SetRenderCustomDepth. Check on the value of the node and connect the begin point of

the SetRenderCustomDepth to SetHomingTarget and then from SetHomingTarget begin

point to the endpoint of the other SetRenderCustomDepth. Then save and compile. Next

part we need to backtrack a bit.

41. Back on step 36, we dragged from the Branch TRUE to establish the behavior of the

homing targeting when a target was a positive, but what about when there is no target

and there is walls only or the floor. Well now we are going to focus back from the false

endpoint onward to set this aforementioned behavior. Drag from Branch FALSE and add

an IsValid node. Then, from the HomingTarget node, drag to the input object begin point

of the IsValid node.

42. Drag from the HomingTarget node once again and add another SetRenderCustomDepth

node. Check the value box again and connect the main begin point to the IsValid

endpoint.

43. Ok, now we have a really cluttered blueprint, go ahead and select the entire thing. Add

the following comment to the selection: Targeting For Missile. Compile it and save it.

44. Right now, it wont do anything yet, but what we need is to migrate some highlight

material from the content example sample map. Download the map (the map is quite

heavy 2.5GB, but consider that the highlight feature is not available on UE4 by default).

Then we will continue with this tutorial.