.. _doc_fps_tutorial_part_five: 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! .. image:: img/PartFiveFinished.png .. note:: You are assumed to have finished :ref:`doc_fps_tutorial_part_four` before moving on to this part of the tutorial. The finished project from :ref:`doc_fps_tutorial_part_four` 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 :ref:`RigidBody ` nodes. We're going to use :ref:`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 :ref:`Area ` node that will represent the blast radius of our grenade. Finally, the last thing to note is ``Explosion``. This is the :ref:`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 :ref:`CollisionShape ` for the grenade's :ref:`RigidBody `. * ``grenade_mesh``: The :ref:`MeshInstance ` for the grenade. * ``blast_area``: The blast :ref:`Area ` used to damage things when the grenade explodes. * ``explosion_particles``: The :ref:`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 :ref:`CollisionShape ` and :ref:`MeshInstance ` because similarly to the target in :ref:`doc_fps_tutorial_part_four`, 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 :ref:`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 :ref:`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 :ref:`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 :ref:`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 :ref:`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 :ref:`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 :ref:`PhysicsBody `. * ``attach_point``: A variable to hold a :ref:`Spatial ` that will be at the position we collided at. * ``player_body``: The player's :ref:`KinematicBody `. These additions are so we can stick to any :ref:`PhysicsBody ` we happen to hit. We also now need the player's :ref:`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 :ref:`Area ` does not know it's attached to the grenade's :ref:`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 :ref:`Spatial ` node, and make it a child of the body we collided with. We then set the :ref:`Spatial `'s position to our current position. .. note:: Because we've added the :ref:`Spatial ` as a child of the body we've collided with, it will follow along with said body. We can then use this :ref:`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 :ref:`Transform `'s origin) to the global position of the :ref:`Spatial ` assigned to ``attach_point`` (using its global :ref:`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 :ref:`Transform ` to ``Grenade_Toss_Pos``'s global :ref:`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 :ref:`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 :ref:`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 :ref:`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 :ref:`RigidBody `. We first get the direct space state from the current :ref:`World `. This is so we can cast a ray entirely from code, instead of having to use a :ref:`Raycast ` node. .. note:: see :ref:`Ray-casting ` for more information on raycasting in Godot. Then we get the center of the screen by dividing the current :ref:`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 :ref:`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 :ref:`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 :ref:`RigidBody `. If the ray collided with a :ref:`RigidBody `, we set ``grabbed_object`` to the collider the ray collided with. We then set the mode on the :ref:`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 :ref:`RigidBody ` we're holding. We first set the :ref:`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 :ref:`RigidBody `'s with different modes, you may need to store the mode of the :ref:`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 :ref:`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 :ref:`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`` :ref:`Particles `. Open up ``Base`` and you'll find it's a :ref:`StaticBody ` and a mesh. Open up ``Head`` and you'll find there's several meshes, a :ref:`StaticBody ` and a :ref:`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 :ref:`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 :ref:`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 :ref:`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 :ref:`Raycast ` node attached to the turret's head. * ``node_flash_one``: A variable to hold the first muzzle flash :ref:`MeshInstance `. * ``node_flash_two``: A variable to hold the second muzzle flash :ref:`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 :ref:`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 :ref:`doc_fps_tutorial_part_two`, 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 :ref:`doc_fps_tutorial_part_two`, 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 :ref:`Area ` is a :ref:`KinematicBody ` ..note:: We're assuming the turret only should fire at :ref:`KinematicBody ` nodes, since that's what our player(s) are using. If the body that just the vision :ref:`Area ` is a :ref:`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 :ref:`StaticBody ` nodes from either ``Body`` or ``Head``. Create a new script called ``TurretBodies.gd`` and attach it to whichever :ref:`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 :ref:`NodePath ` to the ``Turret`` node. Now select the other :ref:`StaticBody ` node (either in ``Body`` or ``Head``) and assign ``TurretBodies.gd`` to it. Once the script is attached, assign the :ref:`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 ----------- .. image:: img/PartFiveFinished.png Now you the player can pick up :ref:`RigidBody ` nodes and throw grenades. We now also have turrets to fire at our player. In :ref:`doc_fps_tutorial_part_six`, 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: :download:`Godot_FPS_Part_5.zip `