Part 5

Part Overview

In this part we’re going to add grenades to our player, give our 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

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

There’s a few things to note here, the first and foremost being that our 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 a Area node that will represent the blast radius of our grenade.

Finally, the last thing to note is Explosion. This is the Particles node that will emit an explosion effect when the grenades explodes. One thing to note here is that we have One shot enabled. This is so we emit all of our particles at once. We’re also emitting in 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 it’s Process Material and Draw Passes.

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

extends RigidBody

const GRENADE_DAMAGE = 60

const GRENADE_TIME = 2
var grenade_timer = 0

const EXPLOSION_WAIT_TIME = 0.48
var explosion_wait_timer = 0

var rigid_shape
var grenade_mesh
var blast_area
var explosion_particles

func _ready():
    rigid_shape = $Collision_Shape
    grenade_mesh = $Grenade
    blast_area = $Blast_Area
    explosion_particles = $Explosion

    explosion_particles.emitting = false
    explosion_particles.one_shot = true

func _process(delta):

    if grenade_timer < GRENADE_TIME:
        grenade_timer += delta
        return
    else:
        if explosion_wait_timer <= 0:
            explosion_particles.emitting = true

            grenade_mesh.visible = false
            rigid_shape.disabled = true

            mode = RigidBody.MODE_STATIC

            var bodies = blast_area.get_overlapping_bodies()
            for body in bodies:
                if body.has_method("bullet_hit"):
                    body.bullet_hit(GRENADE_DAMAGE, global_transform.origin)

            # This would be the perfect place to play a sound!


        if explosion_wait_timer < EXPLOSION_WAIT_TIME:
            explosion_wait_timer += delta

            if explosion_wait_timer >= EXPLOSION_WAIT_TIME:
                queue_free()

Let’s go over what’s happening, starting with the global 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 play 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 the length of time the 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 of the nodes we’ll need and assign them to the proper global 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 it explodes. We’ll be using code similar to the knife weapon in our player. We need the Particles so we can emit them when we explode.

After we get all of the nodes and assign them to their global variables, we then make sure the explosion particles are not emitting, and that they are set to emit in one shot.


Now let’s look at _process.

First we check to see if the grenade_timer is less than GRENADE_TIMER. If it is, we add delta and return. This is so we have to wait GRENADE_TIME seconds, allowing our RigidBody to move around.

If grenade_timer is at GRENADE_TIMER or higher, we then need to check if we waited long enough and need 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 we’ve waited long enough and need to explode.

If we’ve 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 our grenade.

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

Then we get all of 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 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_time.

Next we check to see if explosion_wait_timer is more than or equal to EXPLOSTION_WAIT_TIME. Because we added delta, this will only be called once. If explosion_wait_timer is more or equal to EXPLOSION_WAIT_TIME, we’ve waited long enough to let the Particles play and can free/destroy ourselves.


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’ll be using Stick_Area to detect when we’ve collided with the environment and need to stick to something.

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

extends RigidBody

const GRENADE_DAMAGE = 40

const GRENADE_TIME = 3
var grenade_timer = 0

const EXPLOSION_WAIT_TIME = 0.48
var explosion_wait_timer = 0

var attached = false
var attach_point = null

var rigid_shape
var grenade_mesh
var blast_area
var explosion_particles

var player_body

func _ready():
    rigid_shape = $Collision_Shape
    grenade_mesh = $Sticky_Grenade
    blast_area = $Blast_Area
    explosion_particles = $Explosion

    explosion_particles.emitting = false
    explosion_particles.one_shot = true

    $Sticky_Area.connect("body_entered", self, "collided_with_body")


func collided_with_body(body):

    if body == self:
        return

    if player_body != null:
        if body == player_body:
            return

    if attached == false:
        attached = true
        attach_point = Spatial.new()
        body.add_child(attach_point)
        attach_point.global_transform.origin = global_transform.origin

        rigid_shape.disabled = true

        mode = RigidBody.MODE_STATIC


func _process(delta):

    if attached == true:
        if attach_point != null:
            global_transform.origin = attach_point.global_transform.origin

    if grenade_timer < GRENADE_TIME:
        grenade_timer += delta
        return
    else:
        if explosion_wait_timer <= 0:
            explosion_particles.emitting = true

            grenade_mesh.visible = false
            rigid_shape.disabled = true

            mode = RigidBody.MODE_STATIC

            var bodies = blast_area.get_overlapping_bodies()
            for body in bodies:
                if body.has_method("bullet_hit"):
                    body.bullet_hit(GRENADE_DAMAGE, global_transform.origin)

            # This would be the perfect place to play a sound!


        if explosion_wait_timer < EXPLOSION_WAIT_TIME:
            explosion_wait_timer += delta

            if explosion_wait_timer >= EXPLOSION_WAIT_TIME:
                if attach_point != null:
                    attach_point.queue_free()
                queue_free()

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

First, we have a few more global variables:

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

These additions are so we can stick to any PhysicsBody we happen to hit. We also now need the player’s KinematicBody so we don’t stick to the player that threw this grenade.


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.

First we make sure we’re not colliding with ourself. Because our Area does not know it’s attached to the grenade’s RigidBody, we need to make sure we’re not going to stick to ourself. 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 we collided with is the player that threw this grenade. If the body we’ve collided with is indeed player_body, we ignore it by returning.

Next we check if we are attached already or not.

If we are not attached, we then set attached to true so we know we’ve attached to something.

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

Note

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

We then disable rigid_shape so we’re not constantly moving whatever body we’ve 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 we are attached right at the top of _process.

If we are attached, we then make sure the attached point is not equal to null. If the attached point is not equal to null, we set our global position (using our 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 grenade, we check to see if we have an attached point. If we do, we also call queue_free on it, 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 our grenades.

First, 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 the grenades are tossed at.

Okay, now lets start making the grenades work with our player. Add the following global variables to Player.gd:

var grenade_amounts = {"Grenade":2, "Sticky Grenade":2}
var current_grenade = "Grenade"
var grenade_scene = preload("res://Grenade.tscn")
var sticky_grenade_scene = preload("res://Sticky_Grenade.tscn")
const GRENADE_THROW_FORCE = 50
  • grenade_amounts: The amount of grenades we are currently carrying for each type of grenade.
  • current_grenade: The name of the grenade type we’re 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 we throw the grenade at.

Most of these variables are similar to how we have out 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:

# ----------------------------------
# Changing and throwing grenades

if Input.is_action_just_pressed("change_grenade"):
    if current_grenade == "Grenade":
        current_grenade = "Sticky Grenade"
    elif current_grenade == "Sticky Grenade":
        current_grenade = "Grenade"

if Input.is_action_just_pressed("fire_grenade"):
    if grenade_amounts[current_grenade] > 0:
        grenade_amounts[current_grenade] -= 1

        var grenade_clone
        if (current_grenade == "Grenade"):
            grenade_clone = grenade_scene.instance()
        elif (current_grenade == "Sticky Grenade"):
            grenade_clone = sticky_grenade_scene.instance()
            # Sticky grenades will stick to the player if we do not pass ourselves
            grenade_clone.player_body = self

        get_tree().root.add_child(grenade_clone)
        grenade_clone.global_transform = $Rotation_Helper/Grenade_Toss_Pos.global_transform
        grenade_clone.apply_impulse(Vector3(0,0,0), grenade_clone.global_transform.basis.z * GRENADE_THROW_FORCE)
# ----------------------------------

Let’s go over what’s happening here.

First, we check to see if the change_grenade action has just been pressed. If it has, we then check to see which grenade we are currently using. Based on the name of the grenade we’re 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 we have more than 0 grenades for the current grenade we have selected.

If we have more than 0 grenades, we then remove one from the grenade amounts for the current grenade. Then, based on the grenade we’re 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 we can use both types of grenades, but there’s a few things we should probably add before we move on to adding the other things.

We still need a way to see how many grenades we have left, and we should probably have a way to get more grenades when we pick up ammo.

First, let’s change some of the code in Player.gd so we can see how many grenades we have left. Change process_UI to the following:

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

Now we’ll show how many grenades we have left in our UI.

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

func add_grenade(additional_grenade):
    grenade_amounts[current_grenade] += additional_grenade
    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 you 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:

func trigger_body_entered(body):
    if body.has_method("add_ammo"):
        body.add_ammo(AMMO_AMOUNTS[kit_size])
        respawn_timer = RESPAWN_TIME
        kit_size_change_values(kit_size, false)

    if body.has_method("add_grenade"):
        body.add_grenade(GRENADE_AMOUNTS[kit_size])
        respawn_timer = RESPAWN_TIME
        kit_size_change_values(kit_size, false)

Now we’re 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’re using a new constant we haven’t defined yet, GRENADE_AMOUNTS. Let’s add it! Add the following global variable to AmmoPickup.gd with the other global variables:

const GRENADE_AMOUNTS = [2, 0]
  • GRENADE_AMOUNTS: The amount of grenades each pick up in each size contains.

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


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

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

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

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

var grabbed_object = null
const OBJECT_THROW_FORCE = 120
const OBJECT_GRAB_DISTANCE = 7
const OBJECT_GRAB_RAY_DISTANCE = 10
  • grabbed_object: A variable to hold the grabbed RigidBody node.
  • OBJECT_THROW_FORCE: The force we throw the grabbed object at.
  • OBJECT_GRAB_DISTANCE: The distance away from the camera we hold the grabbed object at.
  • OBJECT_GRAB_RAY_DISTANCE: The distance the Raycast goes. This is our grab distance.

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

# ----------------------------------
# Grabbing and throwing objects

if Input.is_action_just_pressed("fire") and current_weapon_name == "UNARMED":
    if grabbed_object == null:
        var state = get_world().direct_space_state

        var center_position = get_viewport().size/2
        var ray_from = camera.project_ray_origin(center_position)
        var ray_to = ray_from + camera.project_ray_normal(center_position) * OBJECT_GRAB_RAY_DISTANCE

        var ray_result = state.intersect_ray(ray_from, ray_to, [self, $Rotation_Helper/Gun_Fire_Points/Knife_Point/Area])
        if ray_result:
            if ray_result["collider"] is RigidBody:
                grabbed_object = ray_result["collider"]
                grabbed_object.mode = RigidBody.MODE_STATIC

                grabbed_object.collision_layer = 0
                grabbed_object.collision_mask = 0

    else:
        grabbed_object.mode = RigidBody.MODE_RIGID

        grabbed_object.apply_impulse(Vector3(0,0,0), -camera.global_transform.basis.z.normalized() * OBJECT_THROW_FORCE)

        grabbed_object.collision_layer = 1
        grabbed_object.collision_mask = 1

        grabbed_object = null

if grabbed_object != null:
    grabbed_object.global_transform.origin = camera.global_transform.origin + (-camera.global_transform.basis.z.normalized() * OBJECT_GRAB_DISTANCE)
# ----------------------------------

Let’s go over what’s happening.

First we check to see if the action pressed is the fire action, and that we are using the UNARMED weapon. This is because we only want to be able to pick up and throw objects when we’re 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 our ray into the space state and see if we get a result. We add ourselves and the knife’s Area as two exceptions so we cannot carry ourselves or the knife’s collision area.

Then we check to see if we got a result back. 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’s not moved.

Finally, we set its collision layer and collision mask to 0. This will make it have no collision layer or mask, which will means it will not be able to collide with anything.


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

We first set the RigidBody we holding mode to MODE_RIGID.

Note

This is making a rather large assumption that the all 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 RigidBody’s with different modes, you may need to store the mode of the RigidBody you have picked up into a global 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, at OBJECT_THROW_FORCE force.

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 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 before you change them to 0.

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


The last thing we do is check to see whether or not grabbed_object is equal to null, outside of the grabbing/throwing 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 we are 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 we’re holding an object, we don’t want to be able to change weapons or reload, so change _physics_process to the following:

func _physics_process(delta):
    process_input(delta)
    process_view_input(delta)
    process_movement(delta)

    if grabbed_object == null:
        process_changing_weapons(delta)
        process_reloading(delta)

    # Process the UI
    process_UI(delta)

Now we cannot change weapons or reload while holding an object.

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

Adding a turret

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

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

Notice how our turret is broken up into several parts. We have a Base, Head, Vision_Area, and a Smoke Particles.

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

One thing to note with the Head is that the raycast will be where our 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 a 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 writting the code for the turret. Select Turret and create a new script called Turret.gd. Add the following to Turret.gd:

extends Spatial

export (bool) var use_raycast = false

const TURRET_DAMAGE_BULLET = 20
const TURRET_DAMAGE_RAYCAST = 5

const FLASH_TIME = 0.1
var flash_timer = 0

const FIRE_TIME = 0.8
var fire_timer = 0

var node_turret_head = null
var node_raycast = null
var node_flash_one = null
var node_flash_two = null

var ammo_in_turret = 20
const AMMO_IN_FULL_TURRET = 20
const AMMO_RELOAD_TIME = 4
var ammo_reload_timer = 0

var current_target = null

var is_active = false

const PLAYER_HEIGHT = 3

var smoke_particles

var turret_health = 60
const MAX_TURRET_HEALTH = 60

const DESTROYED_TIME = 20
var destroyed_timer = 0

var bullet_scene = preload("Bullet_Scene.tscn")

func _ready():

    $Vision_Area.connect("body_entered", self, "body_entered_vision")
    $Vision_Area.connect("body_exited", self, "body_exited_vision")

    node_turret_head = $Head
    node_raycast = $Head/Ray_Cast
    node_flash_one = $Head/Flash
    node_flash_two = $Head/Flash_2

    node_raycast.add_exception(self)
    node_raycast.add_exception($Base/Static_Body)
    node_raycast.add_exception($Head/Static_Body)
    node_raycast.add_exception($Vision_Area)

    node_flash_one.visible = false
    node_flash_two.visible = false

    smoke_particles = $Smoke
    smoke_particles.emitting = false

    turret_health = MAX_TURRET_HEALTH


func _physics_process(delta):

    if is_active == true:

        if flash_timer > 0:
            flash_timer -= delta

            if flash_timer <= 0:
                node_flash_one.visible = false
                node_flash_two.visible = false

        if current_target != null:

            node_turret_head.look_at(current_target.global_transform.origin + Vector3(0, PLAYER_HEIGHT, 0), Vector3(0, 1, 0))

            if turret_health > 0:

                if ammo_in_turret > 0:
                    if fire_timer > 0:
                        fire_timer -= delta
                    else:
                        fire_bullet()
                else:
                    if ammo_reload_timer > 0:
                        ammo_reload_timer -= delta
                    else:
                        ammo_in_turret = AMMO_IN_FULL_TURRET

    if turret_health <= 0:
        if destroyed_timer > 0:
            destroyed_timer -= delta
        else:
            turret_health = MAX_TURRET_HEALTH
            smoke_particles.emitting = false


func fire_bullet():
    if use_raycast == false:

        var clone = bullet_scene.instance()
        var scene_root = get_tree().root.get_children()[0]
        scene_root.add_child(clone)

        clone.global_transform = $Head/Barrel_End.global_transform
        clone.scale = Vector3(8, 8, 8)
        clone.BULLET_DAMAGE = TURRET_DAMAGE_BULLET
        clone.BULLET_SPEED = 60

        ammo_in_turret -= 1

    else:
        node_raycast.look_at(current_target.global_transform.origin + PLAYER_HEIGHT, Vector3(0,1,0))

        node_raycast.force_raycast_update()

        if node_raycast.is_colliding():
            var body = node_raycast.get_collider()
            if body.has_method("bullet_hit"):
                body.bullet_hit(TURRET_DAMAGE_RAYCAST, node_raycast.get_collision_point())

        ammo_in_turret -= 1

    node_flash_one.visible = true
    node_flash_two.visible = true

    flash_timer = FLASH_TIME
    fire_timer = FIRE_TIME

    if ammo_in_turret <= 0:
        ammo_reload_timer = AMMO_RELOAD_TIME


func body_entered_vision(body):
    if current_target == null:
        if body is KinematicBody:
            current_target = body
            is_active = true


func body_exited_vision(body):
    if current_target != null:
        if body == current_target:
            current_target = null
            is_active = false

            flash_timer = 0
            fire_timer = 0
            node_flash_one.visible = false
            node_flash_two.visible = false


func bullet_hit(damage, bullet_hit_pos):
    turret_health -= damage

    if turret_health <= 0:
        smoke_particles.emitting = true
        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 global variables:

  • use_raycast: A 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)

Phew, that’s quite a few global variables!


Let’s go through _ready next.

First 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 of the nodes and assign them to their respective variables.

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

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

We then get the smoke particles node and assign it to the smoke_particles node. We also set emitting to false to assure it’s 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.

First we check to see if the turret is active. If the turret is active we want to process the firing code.

Next we check to see if flash_timer is more 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 to see if we have a target or not. If we have a target, we make the turret head look at it, adding PLAYER_HEIGHT so we’re not aiming at the player’s feet.

We then check to see if the turret’s health is more than zero. If it is, we then check to see if there is ammo in the turret.

If there is ammo in the turret, we then check to see if fire_timer is more than zero. If fire_timer is more than zero, we cannot fire and need to remove delta from fire_timer. If fire_timer is equal to or less than zero, we want to fire a bullet, so we call the fire_bullet function.

If there is not any ammo in the turret, we check to see if ammo_reload_timer is more than zero. If ammo_reload_timer is more than zero, we subtract delta from ammo_reload_timer. If ammo_reload_timer is equal to or less than zero, we set ammo_in_turret to AMMO_IN_FULL_TURRET because we’ve waited long enough to refill the turret.

Next we check to see if the turret’s health is less than or equal to 0, outside of whether we’re active or not. If the turret’s health is zero or less, we then check to see if destroyed_timer is more than zero. If destroyed timer is more than zero, we subtract delta from destroyed_timer.

If destyored_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.

First we check to see whether we’re using a raycast or not.

The code for the 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, assuring we’ll hit the target. We then force the raycast to update so we get a frame perfect collision check. We then check if the raycast collided with anything. If the raycast has collided with something, we then check to see if the collided body has the bullet_hit function. If it does, we call it and pass in the damage a single raycast bullet does. We then remove 1 from ammo_in_turret.

If we are 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 it’s global transform to the barrel end, scale it up since it’s too small, and set it’s damage and speed using the turret’s constant global variables. We then remove 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 to FLASH_TIME and FIRE_TIME respectively. We then check to see if we used the last bullet in the turret. If we have used the last bullet, we set ammo_reload_timer to AMMO_RELOAD_TIME.


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

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

..note:: We’re assuming the turret only should fire at KinematicBody nodes, since that’s what our player(s) are using.

If the body that just 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.

First we check to see if we have a target. If we have a target, we then check to see if the body that has just left our vision area is our target.

If the body that just left the area is the current target, we set current_target to null, set is_active to false, and reset all of the variables related to firing the turret, since we no longer have a target to fire at.


Finally, let’s look at bullet_hit.

We first remove however much damage we have received from the turret’s health.

Then we check to see if we’ve been destroyed. If we have, we start the smoke particles emitting and set destroyed_timer to DESTROYED_TIME so we have to wait to repair the turret.


Phew, with all of that done and coded we only have one last thing to do before our turrets are ready for use. Open up Turret.tscn if it’s not already open and select one of the StaticBody nodes from either Body 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:

extends StaticBody

export (NodePath) var path_to_turret_root

func _ready():
    pass

func bullet_hit(damage, bullet_hit_pos):
    if path_to_turret_root != null:
        get_node(path_to_turret_root).bullet_hit(damage, bullet_hit_pos)

All this code does is call bullet_hit on whatever node path_to_turret_root leads to. 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 to it. Once the script is attached, assign 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 of our bullets use the bullet_hit function, we need to add that to our player.

Open Player.gd and add the following:

func bullet_hit(damage, bullet_hit_pos):
    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 the player can pick up RigidBody nodes and throw grenades. We now also have turrets to fire at our player.

In Part 6, we’re going to add a main menu and 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