Part 5

Part overview

In this part, we’re going to add grenades to the player, give the player the ability to grab and throw objects, and add turrets!

../../../_images/PartFiveFinished.png

Note

You are assumed to have finished Part 4 before moving on to this part of the tutorial. The finished project from Part 4 will be the starting project for part 5

Let’s get started!

Adding grenades

Firstly, let’s give the player some grenades to play with. Open up Grenade.tscn.

There are a few things to note here, the first and foremost being that the grenades are going to use RigidBody nodes. We’re going to use RigidBody nodes for our grenades so they bounce around the world in a (somewhat) realistic manner.

The second thing to note is Blast_Area. This is an Area node that will represent the blast radius of the grenade.

Finally, the last thing to note is Explosion. This is the Particles node that will emit an explosion effect when the grenade explodes. One thing to note here is that we have One shot enabled. This is so we emit all the particles at once. The particles are also emitted using world coordinates instead of local coordinates, so we have Local Coords unchecked as well.

Note

If you want, you can see how the particles are set up by looking through the particle’s Process Material and Draw Passes.

Let’s write the code needed for the grenade. Select Grenade and make a new script called Grenade.gd. Add the following:

  1. extends RigidBody
  3. const GRENADE_DAMAGE = 60
  5. const GRENADE_TIME = 2
  6. var grenade_timer = 0
  8. const EXPLOSION_WAIT_TIME = 0.48
  9. var explosion_wait_timer = 0
  11. var rigid_shape
  12. var grenade_mesh
  13. var blast_area
  14. var explosion_particles
  16. func _ready():
  17.     rigid_shape = $Collision_Shape
  18.     grenade_mesh = $Grenade
  19.     blast_area = $Blast_Area
  20.     explosion_particles = $Explosion
  22.     explosion_particles.emitting = false
  23.     explosion_particles.one_shot = true
  25. func _process(delta):
  27.     if grenade_timer < GRENADE_TIME:
  28.         grenade_timer += delta
  29.         return
  30.     else:
  31.         if explosion_wait_timer <= 0:
  32.             explosion_particles.emitting = true
  34.             grenade_mesh.visible = false
  35.             rigid_shape.disabled = true
  37.             mode = RigidBody.MODE_STATIC
  39.             var bodies = blast_area.get_overlapping_bodies()
  40.             for body in bodies:
  41.                 if body.has_method("bullet_hit"):
  42.                     body.bullet_hit(GRENADE_DAMAGE, body.global_transform.looking_at(global_transform.origin, Vector3(0, 1, 0)))
  44.             # This would be the perfect place to play a sound!
  47.         if explosion_wait_timer < EXPLOSION_WAIT_TIME:
  48.             explosion_wait_timer += delta
  50.             if explosion_wait_timer >= EXPLOSION_WAIT_TIME:
  51.                 queue_free()

Let’s go over what’s happening, starting with the class variables:

  • GRENADE_DAMAGE: The amount of damage the grenade causes when it explodes.
  • GRENADE_TIME: The amount of time the grenade takes (in seconds) to explode once it’s created/thrown.
  • grenade_timer: A variable for tracking how long the grenade has been created/thrown.
  • EXPLOSION_WAIT_TIME: The amount of time needed (in seconds) to wait before we destroy the grenade scene after the explosion
  • explosion_wait_timer: A variable for tracking how much time has passed since the grenade exploded.
  • rigid_shape: The CollisionShape for the grenade’s RigidBody.
  • grenade_mesh: The MeshInstance for the grenade.
  • blast_area: The blast Area used to damage things when the grenade explodes.
  • explosion_particles: The Particles that come out when the grenade explodes.

Notice how EXPLOSION_WAIT_TIME is a rather strange number (0.48). This is because we want EXPLOSION_WAIT_TIME to be equal to the length of time the explosion particles are emitting, so when the particles are done we destroy/free the grenade. We calculate EXPLOSION_WAIT_TIME by taking the particle’s life time and dividing it by the particle’s speed scale. This gets us the exact time the explosion particles will last.

Now let’s turn our attention to _ready.

First we get all the nodes we’ll need and assign them to the proper class variables.

We need to get the CollisionShape and MeshInstance because similarly to the target in Part 4, we will be hiding the grenade’s mesh and disabling the collision shape when the grenade explodes.

The reason we need to get the blast Area is so we can damage everything inside it when the grenade explodes. We’ll be using code similar to the knife code in the player. We need the Particles so we can emit particles when the grenade explodes.

After we get all the nodes and assign them to their class variables, we then make sure the explosion particles are not emitting, and that they are set to emit in one shot. This is to be extra sure the particles will behave the way we expect them to.

Now let’s look at _process.

Firstly, we check to see if the grenade_timer is less than GRENADE_TIME. If it is, we add delta and return. This is so the grenade has to wait GRENADE_TIME seconds before exploding, allowing the RigidBody to move around.

If grenade_timer is at GRENADE_TIMER or higher, we then need to check if the grenade has waited long enough and needs to explode. We do this by checking to see if explosion_wait_timer is equal to 0 or less. Since we will be adding delta to explosion_wait_timer right after, whatever code under the check will only be called once, right when the grenade has waited long enough and needs to explode.

If the grenade has waited long enough to explode, we first tell the explosion_particles to emit. Then we make grenade_mesh invisible, and disable rigid_shape, effectively hiding the grenade.

We then set the RigidBody’s mode to MODE_STATIC so the grenade does not move.

Then we get all the bodies in blast_area, check to see if they have the bullet_hit method/function, and if they do, we call it and pass in GRENADE_DAMAGE and the transform from the body looking at the grenade. This makes it where the bodies exploded by the grenade will explode outwards from the grenade’s position.

We then check to see if explosion_wait_timer is less than EXPLOSION_WAIT_TIME. If it is, we add delta to explosion_wait_timer.

Next, we check to see if explosion_wait_timer is greater than or equal to EXPLOSION_WAIT_TIME. Because we added delta, this will only be called once. If explosion_wait_timer is greater or equal to EXPLOSION_WAIT_TIME, the grenade has waited long enough to let the Particles play and we can free/destroy the grenade, as we no longer need it.

Let’s quickly get the sticky grenade set up too. Open up Sticky_Grenade.tscn.

Sticky_Grenade.tscn is almost identical to Grenade.tscn, with one small addition. We now have a second Area, called Sticky_Area. We will be using Stick_Area to detect when the sticky grenade has collided with the environment and needs to stick to something.

Select Sticky_Grenade and make a new script called Sticky_Grenade.gd. Add the following:

  1. extends RigidBody
  3. const GRENADE_DAMAGE = 40
  5. const GRENADE_TIME = 3
  6. var grenade_timer = 0
  8. const EXPLOSION_WAIT_TIME = 0.48
  9. var explosion_wait_timer = 0
  11. var attached = false
  12. var attach_point = null
  14. var rigid_shape
  15. var grenade_mesh
  16. var blast_area
  17. var explosion_particles
  19. var player_body
  21. func _ready():
  22.     rigid_shape = $Collision_Shape
  23.     grenade_mesh = $Sticky_Grenade
  24.     blast_area = $Blast_Area
  25.     explosion_particles = $Explosion
  27.     explosion_particles.emitting = false
  28.     explosion_particles.one_shot = true
  30.     $Sticky_Area.connect("body_entered", self, "collided_with_body")
  33. func collided_with_body(body):
  35.     if body == self:
  36.         return
  38.     if player_body != null:
  39.         if body == player_body:
  40.             return
  42.     if attached == false:
  43.         attached = true
  44.         attach_point = Spatial.new()
  45.         body.add_child(attach_point)
  46.         attach_point.global_transform.origin = global_transform.origin
  48.         rigid_shape.disabled = true
  50.         mode = RigidBody.MODE_STATIC
  53. func _process(delta):
  55.     if attached == true:
  56.         if attach_point != null:
  57.             global_transform.origin = attach_point.global_transform.origin
  59.     if grenade_timer < GRENADE_TIME:
  60.         grenade_timer += delta
  61.         return
  62.     else:
  63.         if explosion_wait_timer <= 0:
  64.             explosion_particles.emitting = true
  66.             grenade_mesh.visible = false
  67.             rigid_shape.disabled = true
  69.             mode = RigidBody.MODE_STATIC
  71.             var bodies = blast_area.get_overlapping_bodies()
  72.             for body in bodies:
  73.                 if body.has_method("bullet_hit"):
  74.                     body.bullet_hit(GRENADE_DAMAGE, body.global_transform.looking_at(global_transform.origin, Vector3(0, 1, 0)))
  76.             # This would be the perfect place to play a sound!
  79.         if explosion_wait_timer < EXPLOSION_WAIT_TIME:
  80.             explosion_wait_timer += delta
  82.             if explosion_wait_timer >= EXPLOSION_WAIT_TIME:
  83.                 if attach_point != null:
  84.                     attach_point.queue_free()
  85.                 queue_free()

The code above is almost identical to the code for Grenade.gd, so let’s just go over what’s changed.

Firstly, we have a few more class variables:

  • attached: A variable for tracking whether or not the sticky grenade has attached to a PhysicsBody.
  • attach_point: A variable to hold a Spatial that will be at the position where the sticky grenade collided.
  • player_body: The player’s KinematicBody.

They have been added to enable the sticky grenade to stick to any PhysicsBody it might hit. We also now need the player’s KinematicBody so the sticky grenade does not stick to the player when the player throws it.

Now let’s look at the small change in _ready. In _ready we’ve added a line of code so when any body enters Stick_Area, the collided_with_body function is called.

Next let’s take a look at collided_with_body.

Firstly, we make sure the sticky grenade is not colliding with itself. Because the sticky Area does not know it’s attached to the grenade’s RigidBody, we need to make sure it’s not going to stick to itself by checking to make sure the body it has collided with is not itself. If we have collided with ourself, we ignore it by returning.

We then check to see if we have something assigned to player_body, and if the body the sticky grenade has collided with is the player that threw it. If the body the sticky grenade has collided with is indeed player_body, we ignore it by returning.

Next, we check if the sticky grenade has attached to something already or not.

If the sticky grenade is not attached, we then set attached to true so we know the sticky grenade has attached to something.

We then make a new Spatial node, and make it a child of the body the sticky grenade collided with. We then set the Spatial’s position to the sticky grenade’s current global position.

Note

Because we’ve added the Spatial as a child of the body the sticky grenade has collided with, it will follow along with said body. We can then use this Spatial to set the sticky grenade’s position, so it is always at the same position relative to the body it collided with.

We then disable rigid_shape so the sticky grenade is not constantly moving whatever body it has collided with. Finally, we set our mode to MODE_STATIC so the grenade does not move.

Finally, lets go over the few changes in _process.

Now we’re checking to see if the sticky grenade is attached right at the top of _process.

If the sticky grenade is attached, we then make sure the attached point is not equal to null. If the attached point is not equal to null, we set the sticky grenade’s global position (using its global Transform’s origin) to the global position of the Spatial assigned to attach_point (using its global Transform’s origin).

The only other change is now before we free/destroy the sticky grenade is to check to see if the sticky grenade has an attached point. If it does, we also call queue_free on the attach point, so it’s also freed/destroyed.

Adding grenades to the player

Now we need to add some code to Player.gd so we can use the grenades.

Firstly, open up Player.tscn and expand the node tree until you get to Rotation_Helper. Notice how in Rotation_Helper we have a node called Grenade_Toss_Pos. This is where we will be spawning the grenades.

Also notice how it’s slightly rotated on the X axis, so it’s not pointing straight, but rather slightly up. By changing the rotation of Grenade_Toss_Pos, you can change the angle at which the grenades are tossed.

Okay, now let’s start making the grenades work with the player. Add the following class variables to Player.gd:

  1. var grenade_amounts = {"Grenade":2, "Sticky Grenade":2}
  2. var current_grenade = "Grenade"
  3. var grenade_scene = preload("res://Grenade.tscn")
  4. var sticky_grenade_scene = preload("res://Sticky_Grenade.tscn")
  5. const GRENADE_THROW_FORCE = 50
  • grenade_amounts: The amount of grenades the player is currently carrying (for each type of grenade).
  • current_grenade: The name of the grenade the player is currently using.
  • grenade_scene: The grenade scene we worked on earlier.
  • sticky_grenade_scene: The sticky grenade scene we worked on earlier.
  • GRENADE_THROW_FORCE: The force at which the player will throw the grenades.

Most of these variables are similar to how we have our weapons set up.

Tip

While it’s possible to make a more modular grenade system, I found it was not worth the additional complexity for just two grenades. If you were going to make a more complex FPS with more grenades, you’d likely want to make a system for grenades similar to how we have the weapons set up.

Now we need to add some code in _process_input Add the following to _process_input:

  1. # ----------------------------------
  2. # Changing and throwing grenades
  4. if Input.is_action_just_pressed("change_grenade"):
  5.     if current_grenade == "Grenade":
  6.         current_grenade = "Sticky Grenade"
  7.     elif current_grenade == "Sticky Grenade":
  8.         current_grenade = "Grenade"
  10. if Input.is_action_just_pressed("fire_grenade"):
  11.     if grenade_amounts[current_grenade] > 0:
  12.         grenade_amounts[current_grenade] -= 1
  14.         var grenade_clone
  15.         if current_grenade == "Grenade":
  16.             grenade_clone = grenade_scene.instance()
  17.         elif current_grenade == "Sticky Grenade":
  18.             grenade_clone = sticky_grenade_scene.instance()
  19.             # Sticky grenades will stick to the player if we do not pass ourselves
  20.             grenade_clone.player_body = self
  22.         get_tree().root.add_child(grenade_clone)
  23.         grenade_clone.global_transform = $Rotation_Helper/Grenade_Toss_Pos.global_transform
  24.         grenade_clone.apply_impulse(Vector3(0, 0, 0), grenade_clone.global_transform.basis.z * GRENADE_THROW_FORCE)
  25. # ----------------------------------

Let’s go over what’s happening here.

Firstly, we check to see if the change_grenade action has just been pressed. If it has, we then check to see which grenade the player is currently using. Based on the name of the grenade the player is currently using, we change current_grenade to the opposite grenade name.

Next we check to see if the fire_grenade action has just been pressed. If it has, we then check to see if the player has more than 0 grenades for the current grenade type selected.

If the player has more than 0 grenades, we then remove one from the grenade amounts for the current grenade. Then, based on the grenade the player is currently using, we instance the proper grenade scene and assign it to grenade_clone.

Next we add grenade_clone as a child of the node at the root and set its global Transform to Grenade_Toss_Pos’s global Transform. Finally, we apply an impulse to the grenade so that it is launched forward, relative to the Z directional vector of grenade_clone’s.

Now the player can use both types of grenades, but there are still a few things we should probably add before we move on to adding the other things.

We still need a way to show the player how many grenades are left, and we should probably add a way to get more grenades when the player picks up ammo.

Firstly, let’s change some of the code in Player.gd to show how many grenades are left. Change process_UI to the following:

  1. func process_UI(delta):
  2.     if current_weapon_name == "UNARMED" or current_weapon_name == "KNIFE":
  3.         # First line: Health, second line: Grenades
  4.         UI_status_label.text = "HEALTH: " + str(health) + \
  5.                 "\n" + current_grenade + ": " + str(grenade_amounts[current_grenade])
  6.     else:
  7.         var current_weapon = weapons[current_weapon_name]
  8.         # First line: Health, second line: weapon and ammo, third line: grenades
  9.         UI_status_label.text = "HEALTH: " + str(health) + \
  10.                 "\nAMMO: " + str(current_weapon.ammo_in_weapon) + "/" + str(current_weapon.spare_ammo) + \
  11.                 "\n" + current_grenade + ": " + str(grenade_amounts[current_grenade])

Now we’ll show how many grenades the player has left in the UI.

While we’re still in Player.gd, let’s add a function to add grenades to the player. Add the following function to Player.gd:

  1. func add_grenade(additional_grenade):
  2.     grenade_amounts[current_grenade] += additional_grenade
  3.     grenade_amounts[current_grenade] = clamp(grenade_amounts[current_grenade], 0, 4)

Now we can add a grenade using add_grenade, and it will automatically be clamped to a maximum of 4 grenades.

Tip

You can change the 4 to a constant if you want. You’d need to make a new global constant, something like MAX_GRENADES, and then change the clamp from clamp(grenade_amounts[current_grenade], 0, 4) to clamp(grenade_amounts[current_grenade], 0, MAX_GRENADES)

If you do not want to limit how many grenades the player can carry, remove the line that clamps the grenades altogether!

Now we have a function to add grenades, let’s open up AmmoPickup.gd and use it!

Open up AmmoPickup.gd and go to the trigger_body_entered function. Change it to the following:

  1. func trigger_body_entered(body):
  2.     if body.has_method("add_ammo"):
  3.         body.add_ammo(AMMO_AMOUNTS[kit_size])
  4.         respawn_timer = RESPAWN_TIME
  5.         kit_size_change_values(kit_size, false)
  7.     if body.has_method("add_grenade"):
  8.         body.add_grenade(GRENADE_AMOUNTS[kit_size])
  9.         respawn_timer = RESPAWN_TIME
  10.         kit_size_change_values(kit_size, false)

Now we are also checking to see if the body has the add_grenade function. If it does, we call it like we call add_ammo.

You may have noticed we are using a new constant we have not defined yet, GRENADE_AMOUNTS. Let’s add it! Add the following class variable to AmmoPickup.gd with the other class variables:

  1. const GRENADE_AMOUNTS = [2, 0]
  • GRENADE_AMOUNTS: The amount of grenades each pickup contains.

Notice how the second element in GRENADE_AMOUNTS is 0. This is so the small ammo pickup does not give the player any additional grenades.

Now you should be able to throw grenades! Go give it a try!

Adding the ability to grab and throw RigidBody nodes to the player

Next, let’s give the player the ability to pick up and throw RigidBody nodes.

Open up Player.gd and add the following class variables:

  1. var grabbed_object = null
  2. const OBJECT_THROW_FORCE = 120
  3. const OBJECT_GRAB_DISTANCE = 7
  4. const OBJECT_GRAB_RAY_DISTANCE = 10
  • grabbed_object: A variable to hold the grabbed RigidBody node.
  • OBJECT_THROW_FORCE: The force with which the player throws the grabbed object.
  • OBJECT_GRAB_DISTANCE: The distance away from the camera at which the player holds the grabbed object.
  • OBJECT_GRAB_RAY_DISTANCE: The distance the Raycast goes. This is the player’s grab distance.

With that done, all we need to do is add some code to process_input:

  1. # ----------------------------------
  2. # Grabbing and throwing objects
  4. if Input.is_action_just_pressed("fire") and current_weapon_name == "UNARMED":
  5.     if grabbed_object == null:
  6.         var state = get_world().direct_space_state
  8.         var center_position = get_viewport().size / 2
  9.         var ray_from = camera.project_ray_origin(center_position)
  10.         var ray_to = ray_from + camera.project_ray_normal(center_position) * OBJECT_GRAB_RAY_DISTANCE
  12.         var ray_result = state.intersect_ray(ray_from, ray_to, [self, $Rotation_Helper/Gun_Fire_Points/Knife_Point/Area])
  13.         if ray_result != null:
  14.             if ray_result["collider"] is RigidBody:
  15.                 grabbed_object = ray_result["collider"]
  16.                 grabbed_object.mode = RigidBody.MODE_STATIC
  18.                 grabbed_object.collision_layer = 0
  19.                 grabbed_object.collision_mask = 0
  21.     else:
  22.         grabbed_object.mode = RigidBody.MODE_RIGID
  24.         grabbed_object.apply_impulse(Vector3(0, 0, 0), -camera.global_transform.basis.z.normalized() * OBJECT_THROW_FORCE)
  26.         grabbed_object.collision_layer = 1
  27.         grabbed_object.collision_mask = 1
  29.         grabbed_object = null
  31. if grabbed_object != null:
  32.     grabbed_object.global_transform.origin = camera.global_transform.origin + (-camera.global_transform.basis.z.normalized() * OBJECT_GRAB_DISTANCE)
  33. # ----------------------------------

Let’s go over what’s happening.

Firstly, we check to see if the action pressed is the fire action, and that the player is using the UNARMED ‘weapon’. This is because we only want the player to be able to pick up and throw objects when the player is not using any weapons. This is a design choice, but I feel it gives UNARMED a use.

Next we check to see whether or not grabbed_object is null.

If grabbed_object is null, we want to see if we can pick up a RigidBody.

We first get the direct space state from the current World. This is so we can cast a ray entirely from code, instead of having to use a Raycast node.

Note

see Ray-casting for more information on raycasting in Godot.

Then we get the center of the screen by dividing the current Viewport size in half. We then get the ray’s origin point and end point using project_ray_origin and project_ray_normal from the camera. If you want to know more about how these functions work, see Ray-casting.

Next we send the ray into the space state and see if it gets a result. We add the player and the knife’s Area as two exceptions so the player cannot carry themselves or the knife’s collision Area.

Then we check to see if we got a result back from the ray. If we have, we then see if the collider the ray collided with is a RigidBody.

If the ray collided with a RigidBody, we set grabbed_object to the collider the ray collided with. We then set the mode on the RigidBody we collided with to MODE_STATIC so it doesn’t move in our hands.

Finally, we set the grabbed RigidBody’s collision layer and collision mask to 0. This will make the grabbed RigidBody have no collision layer or mask, which means it will not be able to collide with anything as long as we are holding it.

If grabbed_object is not null, then we need to throw the RigidBody the player is holding.

We first set the mode of the RigidBody we are holding to MODE_RIGID.

Note

This is making a rather large assumption that all the rigid bodies will be using MODE_RIGID. While that is the case for this tutorial series, that may not be the case in other projects.

If you have rigid bodies with different modes, you may need to store the mode of the RigidBody you have picked up into a class variable so you can change it back to the mode it was in before you picked it up.

Then we apply an impulse to send it flying forward. We send it flying in the direction the camera is facing, using the force we set in the OBJECT_THROW_FORCE variable.

We then set the grabbed RigidBody’s collision layer and mask to 1, so it can collide with anything on layer 1 again.

Note

This is, once again, making a rather large assumption that all the rigid bodies will be only on collision layer 1, and all collision masks will be on layer 1. If you are using this script in other projects, you may need to store the collision layer/mask of the RigidBody in a variable before you change them to 0, so you would have the original collision layer/mask to set for them when you are reversing the process.

Finally, we set grabbed_object to null since the player has successfully thrown the held object.

The last thing we do is check to see whether or not grabbed_object is equal to null, outside all of the grabbing/throwing related code.

Note

While technically not input related, it’s easy enough to place the code moving the grabbed object here because it’s only two lines, and then all of the grabbing/throwing code is in one place

If the player is holding an object, we set its global position to the camera’s position plus OBJECT_GRAB_DISTANCE in the direction the camera is facing.

Before we test this, we need to change something in _physics_process. While the player is holding an object, we do not want the player to be able to change weapons or reload, so change _physics_process to the following:

  1. func _physics_process(delta):
  2.     process_input(delta)
  3.     process_view_input(delta)
  4.     process_movement(delta)
  6.     if grabbed_object == null:
  7.         process_changing_weapons(delta)
  8.         process_reloading(delta)
  10.     # Process the UI
  11.     process_UI(delta)

Now the player cannot change weapons or reload while holding an object.

Now you can grab and throw RigidBody nodes while you’re in the UNARMED state! Go give it a try!

Adding a turret

Next, let’s make a turret to shoot the player!

Open up Turret.tscn. Expand Turret if it’s not already expanded.

Notice how the turret is broken up into several parts: Base, Head, Vision_Area, and a Smoke Particles node.

Open up Base and you’ll find it’s a StaticBody and a mesh. Open up Head and you’ll find there are several meshes, a StaticBody and a Raycast node.

One thing to note with the Head is that the raycast will be where the turret’s bullets will fire from if we are using raycasting. We also have two meshes called Flash and Flash_2. These will be the muzzle flash that briefly shows when the turret fires.

Vision_Area is an Area we’ll use as the turret’s ability to see. When something enters Vision_Area, we’ll assume the turret can see it.

Smoke is a Particles node that will play when the turret is destroyed and repairing.

Now that we’ve looked at how the scene is set up, lets start writing the code for the turret. Select Turret and create a new script called Turret.gd. Add the following to Turret.gd:

  1. extends Spatial
  3. export (bool) var use_raycast = false
  5. const TURRET_DAMAGE_BULLET = 20
  6. const TURRET_DAMAGE_RAYCAST = 5
  8. const FLASH_TIME = 0.1
  9. var flash_timer = 0
  11. const FIRE_TIME = 0.8
  12. var fire_timer = 0
  14. var node_turret_head = null
  15. var node_raycast = null
  16. var node_flash_one = null
  17. var node_flash_two = null
  19. var ammo_in_turret = 20
  20. const AMMO_IN_FULL_TURRET = 20
  21. const AMMO_RELOAD_TIME = 4
  22. var ammo_reload_timer = 0
  24. var current_target = null
  26. var is_active = false
  28. const PLAYER_HEIGHT = 3
  30. var smoke_particles
  32. var turret_health = 60
  33. const MAX_TURRET_HEALTH = 60
  35. const DESTROYED_TIME = 20
  36. var destroyed_timer = 0
  38. var bullet_scene = preload("Bullet_Scene.tscn")
  40. func _ready():
  42.     $Vision_Area.connect("body_entered", self, "body_entered_vision")
  43.     $Vision_Area.connect("body_exited", self, "body_exited_vision")
  45.     node_turret_head = $Head
  46.     node_raycast = $Head/Ray_Cast
  47.     node_flash_one = $Head/Flash
  48.     node_flash_two = $Head/Flash_2
  50.     node_raycast.add_exception(self)
  51.     node_raycast.add_exception($Base/Static_Body)
  52.     node_raycast.add_exception($Head/Static_Body)
  53.     node_raycast.add_exception($Vision_Area)
  55.     node_flash_one.visible = false
  56.     node_flash_two.visible = false
  58.     smoke_particles = $Smoke
  59.     smoke_particles.emitting = false
  61.     turret_health = MAX_TURRET_HEALTH
  64. func _physics_process(delta):
  66.     if is_active == true:
  68.         if flash_timer > 0:
  69.             flash_timer -= delta
  71.             if flash_timer <= 0:
  72.                 node_flash_one.visible = false
  73.                 node_flash_two.visible = false
  75.         if current_target != null:
  77.             node_turret_head.look_at(current_target.global_transform.origin + Vector3(0, PLAYER_HEIGHT, 0), Vector3(0, 1, 0))
  79.             if turret_health > 0:
  81.                 if ammo_in_turret > 0:
  82.                     if fire_timer > 0:
  83.                         fire_timer -= delta
  84.                     else:
  85.                         fire_bullet()
  86.                 else:
  87.                     if ammo_reload_timer > 0:
  88.                         ammo_reload_timer -= delta
  89.                     else:
  90.                         ammo_in_turret = AMMO_IN_FULL_TURRET
  92.     if turret_health <= 0:
  93.         if destroyed_timer > 0:
  94.             destroyed_timer -= delta
  95.         else:
  96.             turret_health = MAX_TURRET_HEALTH
  97.             smoke_particles.emitting = false
  100. func fire_bullet():
  102.     if use_raycast == true:
  103.         node_raycast.look_at(current_target.global_transform.origin + Vector3(0, PLAYER_HEIGHT, 0), Vector3(0, 1, 0))
  105.         node_raycast.force_raycast_update()
  107.         if node_raycast.is_colliding():
  108.             var body = node_raycast.get_collider()
  109.             if body.has_method("bullet_hit"):
  110.                 body.bullet_hit(TURRET_DAMAGE_RAYCAST, node_raycast.get_collision_point())
  112.         ammo_in_turret -= 1
  114.     else:
  115.         var clone = bullet_scene.instance()
  116.         var scene_root = get_tree().root.get_children()[0]
  117.         scene_root.add_child(clone)
  119.         clone.global_transform = $Head/Barrel_End.global_transform
  120.         clone.scale = Vector3(8, 8, 8)
  121.         clone.BULLET_DAMAGE = TURRET_DAMAGE_BULLET
  122.         clone.BULLET_SPEED = 60
  124.         ammo_in_turret -= 1
  126.     node_flash_one.visible = true
  127.     node_flash_two.visible = true
  129.     flash_timer = FLASH_TIME
  130.     fire_timer = FIRE_TIME
  132.     if ammo_in_turret <= 0:
  133.         ammo_reload_timer = AMMO_RELOAD_TIME
  136. func body_entered_vision(body):
  137.     if current_target == null:
  138.         if body is KinematicBody:
  139.             current_target = body
  140.             is_active = true
  143. func body_exited_vision(body):
  144.     if current_target != null:
  145.         if body == current_target:
  146.             current_target = null
  147.             is_active = false
  149.             flash_timer = 0
  150.             fire_timer = 0
  151.             node_flash_one.visible = false
  152.             node_flash_two.visible = false
  155. func bullet_hit(damage, bullet_hit_pos):
  156.     turret_health -= damage
  158.     if turret_health <= 0:
  159.         smoke_particles.emitting = true
  160.         destroyed_timer = DESTROYED_TIME

This is quite a bit of code, so let’s break it down function by function. Let’s first look at the class variables:

  • use_raycast: An exported boolean so we can change whether the turret uses objects or raycasting for bullets.
  • TURRET_DAMAGE_BULLET: The amount of damage a single bullet scene does.
  • TURRET_DAMAGE_RAYCAST: The amount of damage a single Raycast bullet does.
  • FLASH_TIME: The amount of time (in seconds) the muzzle flash meshes are visible.
  • flash_timer: A variable for tracking how long the muzzle flash meshes have been visible.
  • FIRE_TIME: The amount of time (in seconds) needed to fire a bullet.
  • fire_timer: A variable for tracking how much time has passed since the turret last fired.
  • node_turret_head: A variable to hold the Head node.
  • node_raycast: A variable to hold the Raycast node attached to the turret’s head.
  • node_flash_one: A variable to hold the first muzzle flash MeshInstance.
  • node_flash_two: A variable to hold the second muzzle flash MeshInstance.
  • ammo_in_turret: The amount of ammo currently in the turret.
  • AMMO_IN_FULL_TURRET: The amount of ammo in a full turret.
  • AMMO_RELOAD_TIME: The amount of time it takes the turret to reload.
  • ammo_reload_timer: A variable for tracking how long the turret has been reloading.
  • current_target: The turret’s current target.
  • is_active: A variable for tracking whether the turret is able to fire at the target.
  • PLAYER_HEIGHT: The amount of height we’re adding to the target so we’re not shooting at its feet.
  • smoke_particles: A variable to hold the smoke particles node.
  • turret_health: The amount of health the turret currently has.
  • MAX_TURRET_HEALTH: The amount of health a fully healed turret has.
  • DESTROYED_TIME: The amount of time (in seconds) it takes for a destroyed turret to repair itself.
  • destroyed_timer: A variable for tracking the amount of time a turret has been destroyed.
  • bullet_scene: The bullet scene the turret fires (same scene as the player’s pistol)

Whew, that’s quite a few class variables!

Let’s go through _ready next.

Firstly, we get the vision area and connect the body_entered and body_exited signals to body_entered_vision and body_exited_vision, respectively.

We then get all the nodes and assign them to their respective variables.

Next, we add some exceptions to the Raycast so the turret cannot hurt itself.

Then we make both flash meshes invisible at start, since we are not going to be firing during _ready.

We then get the smoke particles node and assign it to the smoke_particles variable. We also set emitting to false to ensure the particles are not emitting until the turret is broken.

Finally, we set the turret’s health to MAX_TURRET_HEALTH so it starts at full health.

Now let’s go through _physics_process.

Firstly, we check whether the turret is active. If the turret is active, we want to process the firing code.

Next, if flash_timer is greater than zero, meaning the flash meshes are visible, we want to remove delta from flash_timer. If flash_timer gets to zero or less after we’ve subtracted delta, we want to hide both of the flash meshes.

Next, we check whether the turret has a target. If the turret has a target, we make the turret head look at it, adding PLAYER_HEIGHT so it is not aiming at the player’s feet.

We then check whether the turret’s health is greater than zero. If it is, we then check whether there is ammo in the turret.

If there is, we then check whether fire_timer is greater than zero. If it is, the turret cannot fire and we need to remove delta from fire_timer. If fire_timer is less than or equal to zero, the turret can fire a bullet, so we call the fire_bullet function.

If there isn’t any ammo in the turret, we check whether ammo_reload_timer is greater than zero. If it is, we subtract delta from ammo_reload_timer. If ammo_reload_timer is less than or equal to zero, we set ammo_in_turret to AMMO_IN_FULL_TURRET because the turret has waited long enough to refill its ammo.

Next, we check whether the turret’s health is less than or equal to 0 outside of whether it is active or not. If the turret’s health is zero or less, we then check whether destroyed_timer is greater than zero. If it is, we subtract delta from destroyed_timer.

If destroyed_timer is less than or equal to zero, we set turret_health to MAX_TURRET_HEALTH and stop emitting smoke particles by setting smoke_particles.emitting to false.

Next let’s go through fire_bullet.

Firstly, we check whether the turret is using a raycast.

The code for using a raycast is almost entirely the same as the code in the rifle from Part 2, so I’m only going to go over it briefly.

We first make the raycast look at the target, ensuring the raycast will hit the target if nothing is in the way. We then force the raycast to update so we get a frame perfect collision check. We then check whether the raycast has collided with anything. If it has, we then check whether the collided body has the bullet_hit method. If it does, we call it and pass in the damage a single raycast bullet does along with the raycast’s transform. We then subtract 1 from ammo_in_turret.

If the turret is not using a raycast, we spawn a bullet object instead. This code is almost entirely the same as the code in the pistol from Part 2, so like with the raycast code, I’m only going to go over it briefly.

We first make a bullet clone and assign it to clone. We then add that as a child of the root node. We set the bullet’s global transform to the barrel end, scale it up since it’s too small, and set its damage and speed using the turret’s constant class variables. We then subtract 1 from ammo_in_turret.

Then, regardless of which bullet method we used, we make both of the muzzle flash meshes visible. We set flash_timer and fire_timer to FLASH_TIME and FIRE_TIME, respectively. We then check whether the turret has used the last bullet in its ammo. If it has, we set ammo_reload_timer to AMMO_RELOAD_TIME so the turret reloads.

Let’s look at body_entered_vision next, and thankfully it is rather short.

We first check whether the turret currently has a target by checking if current_target is equal to null. If the turret does not have a target, we then check whether the body that has just entered the vision Area is a KinematicBody.

Note

We’re assuming the turret should only fire at KinematicBody nodes since that is what the player is using.

If the body that just entered the vision Area is a KinematicBody, we set current_target to the body, and set is_active to true.

Now let’s look at body_exited_vision.

Firstly, we check whether the turret has a target. If it does, we then check whether the body that has just left the turret’s vision Area is the turret’s target.

If the body that has just left the vision Area is the turret’s current target, we set current_target to null, set is_active to false, and reset all the variables related to firing the turret since the turret no longer has a target to fire at.

Finally, let’s look at bullet_hit.

We first subtract however much damage the bullet causes from the turret’s health.

Then, we check whether the turret has been destroyed (health being zero or less). If the turret is destroyed, we start emitting the smoke particles and set destroyed_timer to DESTROYED_TIME so the turret has to wait before being repaired.

Whew, with all of that done and coded, we only have one last thing to do before the turret is ready for use. Open up Turret.tscn if it’s not already open and select one of the StaticBody nodes from either Base or Head. Create a new script called TurretBodies.gd and attach it to whichever StaticBody you have selected.

Add the following code to TurretBodies.gd:

  1. extends StaticBody
  3. export (NodePath) var path_to_turret_root
  5. func _ready():
  6.     pass
  8. func bullet_hit(damage, bullet_hit_pos):
  9.     if path_to_turret_root != null:
  10.         get_node(path_to_turret_root).bullet_hit(damage, bullet_hit_pos)

All this code does is call bullet_hit on whatever node to which path_to_turret_root leads. Go back to the editor and assign the NodePath to the Turret node.

Now select the other StaticBody node (either in Body or Head) and assign TurretBodies.gd script to it. Once the script is attached, assign again the NodePath to the Turret node.

The last thing we need to do is add a way for the player to be hurt. Since all the bullets use the bullet_hit function, we need to add that function to the player.

Open Player.gd and add the following:

  1. func bullet_hit(damage, bullet_hit_pos):
  2.     health -= damage

With all that done, you should have fully operational turrets! Go place a few in one/both/all of the scenes and give them a try!

Final notes

../../../_images/PartFiveFinished.png

Now you can pick up RigidBody nodes and throw grenades. We now also have turrets to fire at the player.

In Part 6, we’re going to add a main menu and a pause menu, add a respawn system for the player, and change/move the sound system so we can use it from any script.

Warning

If you ever get lost, be sure to read over the code again!

You can download the finished project for this part here: Godot_FPS_Part_5.zip