DEV Community

Cover image for Let’s Learn Godot 4 by Making an RPG — Part 11: Spawning Enemy AI🤠
christine
christine

Posted on • Edited on

Let’s Learn Godot 4 by Making an RPG — Part 11: Spawning Enemy AI🤠

#gamedev #beginners #tutorial #programming

Imagine how much work it would be to manually add 50+ enemies to our scene. This not only looks cluttered, but it also means that we will only have 50 enemy’s in our scene, and if we kill them all, they’d be gone until we reload the game. To fix this little conundrum, we can create an Enemy Spawner that will spawn our enemies at random locations throughout the map and at a constant value, meaning we will never have more or fewer enemies than we defined. Each time an enemy is removed by us killing them, the spawner will spawn a new one, and so forth.

We’ll also make our spawner flexible enough so that we can change the spawn area and max enemies in the Inspector panel. This means we can instance multiple spawners in our Main scene to have x amount of enemies spawn in different areas. Does this sound interesting? Well, what are you waiting for? Let’s spawn some enemies!

WHAT YOU WILL LEARN IN THIS PART:
· How to work with the Timer node.
· How to create scene references.
· How to reference nodes in other scenes.
· How to reference TileMap properties.
· How to work with rectangle properties.

First, let’s remove all the instances of the Enemy scene from our Main scene. We won’t instance our enemy like this again since the spawner will take care of that.

Godot RPG

Let’s create a new Scene with a Node2D as its root. This will allow us to draw our enemy nodes onto our scene.

Godot RPG

Rename this Node2D as “EnemySpawner” and save it under your Scenes folder.

Godot RPG

We need to add a Timer node to this scene so that we can spawn an enemy every second — unless we’ve already reached our max enemy amount. Enable AutoStart, because we want this timer to start as soon as our game starts so that we can start spawning enemies.

Godot RPG

Godot RPG

We also need to go back to our Enemy scene and disable the timer there, because we don’t want that Enemy to start moving before they’ve completed spawning. We’ll start this timer later on in the code itself.

Godot RPG

Attach a script to your root node and save it underneath your Scripts folder.

Godot RPG

Finally, let’s add a new Node2D node that will we’ll organize the spawned enemies underneath.

Godot RPG

In this script, we need to define a few variables. These variables will:

  • Randomize our enemy’s spawn position.

  • Set and export the enemy max values.

  • Set and export the enemy’s current spawn count.

  • Set a reference to our Map’s tilemap property so that our enemy doesn’t spawn on certain layers (for example, our water and foliage).

    ###EnemySpawner.gd

    extends Node2D

    # Node refs
    @onready var spawned_enemies = $SpawnedEnemies
    @onready var tilemap = get_tree().root.get_node("Main/Map") 

    # Enemy stats
    @export var max_enemies = 20 
    var enemy_count = 0 
    var rng = RandomNumberGenerator.new()
Enter fullscreen mode Exit fullscreen mode

In our Global script, we’ll also load a reference to our Enemy scene.

    ### Global.gd

    extends Node

    # Scene resources
    @onready var pickups_scene = preload("res://Scenes/Pickup.tscn")
    @onready var enemy_scene = preload("res://Scenes/Enemy.tscn")
Enter fullscreen mode Exit fullscreen mode

To spawn our enemies, we need to create a function that will spawn the existing enemies at the start of the game, and the rest of the enemies when the timer times out. We can call our function spawn_enemy(). In this function, we will create an instance of the reference to our enemy scene. When we create an instance of our scene it saves this as a resource without loading it from the disk each time we call it. This saves space and time.

    ###EnemySpawner.gd

    # older code

    # --------------------------------- Spawning ------------------------------------
    func spawn_enemy():
        var enemy = Global.enemy_scene.instantiate()
Enter fullscreen mode Exit fullscreen mode

Now that we have an instance of our Enemy scene, we can add our enemy as a child of our node hierarchy via the add_child() method. In simple terms, we’re adding enemies from our Enemy scene to our spawner’s scene tree.

    ###EnemySpawner.gd

    # older code

    # --------------------------------- Spawning ------------------------------------
    func spawn_enemy():
        var enemy = Global.enemy_scene.instantiate()
        spawned_enemies.add_child(enemy)
Enter fullscreen mode Exit fullscreen mode

If you think about it logically, you know that you cannot just spawn an enemy in any position. What if our game spawns it under a building? Or in the water? We won’t be able to get to the enemy, so to prevent this issue from happening, we have to create a function that will define the valid spawn positions for our enemy. We’ve done this before in our Pickups spawner. Now depending on the layers that you added to your Tilemap, the next part might be different on your side than it is on mine.

In the part where we added our Map, we created the following layers:

Godot RPG

As you already know, our layers each have an ID assigned to each of them. We start counting at 0, so that means that water == 0, grass == 1, sand == 2, and foliage ==3. We only want our enemy to spawn on our grass(1) or sand(2) layers. Anywhere where our other layers (0, 3) are present, we don’t want them to spawn.

Since we’ll be referencing these layers in both our Pickup spawning functionality and Enemy spawning, let’s redefine the layer constants from our Main script in our Global script. We’ll then also need to reference these constants correctly in our Main script.

    ### Global.gd

    extends Node

    # Scene resources
    @onready var pickups_scene = preload("res://Scenes/Pickup.tscn")
    @onready var enemy_scene = preload("res://Scenes/Enemy.tscn")

    # Pickups
    enum Pickups { AMMO, STAMINA, HEALTH }

    # TileMap layers
    const WATER_LAYER = 0
    const GRASS_LAYER = 1
    const SAND_LAYER = 2
    const FOLIAGE_LAYER = 3
    const EXTERIOR_1_LAYER = 4
    const EXTERIOR_2_LAYER = 5

    ### Main.gd

    # older code

    # --------------------------------------- Pickup spawning -----------------------
    # Valid pickup spawn location
    func is_valid_spawn_location(layer, position):
        var cell_coords = Vector2(position.x, position.y)

        # Check if there's a tile on the water, foliage, or exterior layers
        if map.get_cell_source_id(Global.WATER_LAYER, cell_coords) != -1 || map.get_cell_source_id(Global.FOLIAGE_LAYER, cell_coords) != -1 || map.get_cell_source_id(Global.EXTERIOR_1_LAYER, cell_coords) != -1  || map.get_cell_source_id(Global.EXTERIOR_2_LAYER, cell_coords) != -1:
            return false

        # Check if there's a tile on the grass or sand layers
        if map.get_cell_source_id(Global.GRASS_LAYER, cell_coords) != -1 ||  map.get_cell_source_id(Global.SAND_LAYER, cell_coords) != -1:
            return true

        return false
Enter fullscreen mode Exit fullscreen mode

Now in our EnemySpawner script, let’s copy and paste the entire is_valid_spawn_location() function from our Main script. Replace the variable map with tilemap.

    ###EnemySpawner.gd

    # --------------------------------- Spawning ------------------------------------
    # older code

    # Valid spawn location
    func is_valid_spawn_location(layer, position):
        var cell_coords = Vector2(position.x, position.y)
        # Check if there's a tile on the water, foliage, or exterior layers
        if tilemap.get_cell_source_id(Global.WATER_LAYER, cell_coords) != -1 || tilemap.get_cell_source_id(Global.FOLIAGE_LAYER, cell_coords) != -1 || tilemap.get_cell_source_id(Global.EXTERIOR_1_LAYER, cell_coords) != -1 || tilemap.get_cell_source_id(Global.EXTERIOR_2_LAYER, cell_coords) != -1:
            return false
        # Check if there's a tile on the grass or sand layers
        if tilemap.get_cell_source_id(Global.GRASS_LAYER, cell_coords) != -1 ||  tilemap.get_cell_source_id(Global.SAND_LAYER, cell_coords) != -1:
            return true
        return false
Enter fullscreen mode Exit fullscreen mode

Now in our spawn_enemy function, we need to randomly select a position on the map. We’ll then need to check if that position is a valid spawn location using the is_valid_spawn_location function. If it’s valid, we’ll spawn the enemy at that position. If not, we’ll try another random position. This once again works similarly to what we did when we spawned our pickups.

    ###EnemySpawner.gd

    # --------------------------------- Spawning ------------------------------------
    func spawn_enemy():
        var attempts = 0
        var max_attempts = 100  # Maximum number of attempts to find a valid location
        var spawned = false

        while not spawned and attempts < max_attempts:
            # Randomly select a position on the map
            var random_position = Vector2(
                rng.randi() % tilemap.get_used_rect().size.x,
                rng.randi() % tilemap.get_used_rect().size.y
            )
            # Check if the position is a valid spawn location
            if is_valid_spawn_location(Global.GRASS_LAYER, random_position) || is_valid_spawn_location(Global.SAND_LAYER, random_position):
                # Spawn enemy
                var enemy = Global.enemy_scene.instantiate()
                enemy.position = tilemap.map_to_local(random_position) + Vector2(16, 16) / 2
                spawned_enemies.add_child(enemy)
                spawned = true
            else:
                attempts += 1
        if attempts == max_attempts:
            print("Warning: Could not find a valid spawn location after", max_attempts, "attempts.")
Enter fullscreen mode Exit fullscreen mode

Next, we need to spawn the enemies. We can do this in our Timer node’s timeout() signal. Connect the signal to your scene root, where you will see the func _on_timer_timeout(): function added to the end of your script.

Godot RPG

If our enemy count is not bigger than our max enemies, we will call our spawn_enemies function. This will spawn an enemy every 1 second untill the max amount of enemies allowed have been spawned.

    ###EnemySpawner.gd

    # --------------------------------- Spawning ------------------------------------
    # Spawn enemy
    func _on_timer_timeout():
        if enemy_count < max_enemies:
            spawn_enemy()
            enemy_count = enemy_count + 1
Enter fullscreen mode Exit fullscreen mode

Now if you create an instance of your EnemySpawner scene in your Main scene (make sure you have no Enemy scene in your Main scene), and you run your game, you will notice that the enemies spawn.

Godot RPG

If you don’t want enemies in your scene, just set your spawner values to 0 in the Inspector panel.

Godot RPG

Godot RPG

Ensure that you TileMap node’s transform properties are set to (0,0) — otherwise your enemies will spawn with an offset!

Godot RPG

PICKUP SPAWNER

Whilst we’re at it, let’s create a new scene that will contain our PickupSpawner. This will make our project more dynamic and reusable. Recreate the steps that you took for your EnemySpawner (Create a new scene, add nodes, connect script, connect timeout signal). Please don’t add a Timer node to this scene

Godot RPG

Godot RPG

Godot RPG

Now, in your PickupSpawner.gd script, copy over the code that you added in your Main script into your newly created script.

    ### PickupSpawner.gd

    extends Node2D

    # Node refs
    @onready var map = get_tree().root.get_node("Main/Map")
    @onready var spawned_pickups = $SpawnedPickups

    var rng = RandomNumberGenerator.new()

    func _ready():
        # Spawn between 5 and 10 pickups
        var spawn_pickup_amount = rng.randf_range(5, 10)
        spawn_pickups(spawn_pickup_amount)  

    # --------------------------------------- Pickup spawning -----------------------
    # Valid pickup spawn location
    func is_valid_spawn_location(layer, position):
        var cell_coords = Vector2(position.x, position.y)
        # Check if there's a tile on the water, foliage, or exterior layers
        if map.get_cell_source_id(Global.WATER_LAYER, cell_coords) != -1 || map.get_cell_source_id(Global.FOLIAGE_LAYER, cell_coords) != -1 || map.get_cell_source_id(Global.EXTERIOR_1_LAYER, cell_coords) != -1 || map.get_cell_source_id(Global.EXTERIOR_2_LAYER, cell_coords) != -1:
            return false
        # Check if there's a tile on the grass or sand layers
        if map.get_cell_source_id(Global.GRASS_LAYER, cell_coords) != -1 ||  map.get_cell_source_id(Global.SAND_LAYER, cell_coords) != -1:
            return true
        return false

    # Spawn pickup
    func spawn_pickups(amount):
        var spawned = 0
        var attempts = 0
        var max_attempts = 1000  # Arbitrary number, adjust as needed

        while spawned < amount and attempts < max_attempts:
            attempts += 1
            var random_position = Vector2(randi() % map.get_used_rect().size.x, randi() % map.get_used_rect().size.y)
            var layer = randi() % 2  
            if is_valid_spawn_location(layer, random_position):
                var pickup_instance = Global.pickups_scene.instantiate()
                pickup_instance.item = Global.Pickups.values()[randi() % 3]
                pickup_instance.position = map.map_to_local(random_position) + Vector2(16, 16) / 2
                spawned_pickups.add_child(pickup_instance)
                spawned += 1
Enter fullscreen mode Exit fullscreen mode

Then, in your Main scene, delete the SpawnedPickups node, and instance the PickupSpawner instead. Your Main script should look like the one below.

Godot RPG

    ### Main.gd

    extends Node2D
Enter fullscreen mode Exit fullscreen mode

Now your pickups and enemies should spawn when you run the scene! The enemy should still roam around and chase the player if you come close to them.

Godot RPG

Next up, we’re going to add the functionality for our player to shoot and deal damage to our enemy. Remember to save your game project, and I’ll see you in the next part.

Your final code for this part should look like this.

Buy Me a Coffee at ko-fi.com

FULL TUTORIAL

Godot RPG

The tutorial series has 23 chapters. I’ll be releasing all of the chapters in sectional daily parts over the next couple of weeks.

If you like this series or want to skip the wait and access the offline, full version of the tutorial series, you can support me by buying the offline booklet for just $4 on Ko-fi!😊

You can find the updated list of the tutorial links for all 23 parts in this series here.

Top comments (4)

Collapse
 
wen1223 profile image
Huang • • Edited

Thank you for this great tutorial! It's REALLY helps me with the school project I'm doing!
However, I have a question in the enemy animation part:

func returned_direction(direction : Vector2):
    var normalized_direction  = direction.normalized()
    if normalized_direction.y >= .7:
        return "down"
    elif normalized_direction.y <= -.7:
        return "up"
    elif normalized_direction.x >= .7:
        $AnimatedSprite2D.flip_h = false
        return "side"
    elif normalized_direction.x <= -.7:
        $AnimatedSprite2D.flip_h = true
        return "side"
    return ""
Enter fullscreen mode Exit fullscreen mode

The code that determine the animation of the enemy will always satisfied the first condition or the second condition. I'm not sure will the condition ever get to the third or forth condition?
Another question is : If the auto start of the enemy spawn timer is not turned on, does that mean it will start randomly? I try to track the spawn progress by print(), but the timer is not starting... ( The first 5 is spawned, but the rest is not working ) I also found that the enemy spawn on the sand and grass layer, does that mean I need to erase the sand or grass tile under the physic layer?

Collapse
 
christinec_dev profile image
christine •

The third and fourth conditions will be reached if the x component of the normalized_direction is dominant (i.e., its absolute value is greater than 0.7) and the y component's absolute value is less than 0.7.

For example, if the character points mostly to the right (like (1, 0.5)), after normalization, the x component will be greater than 0.7, and the third condition will be satisfied. If the character points mostly to the left (like (-1, 0.5)), after normalization, the x component will be less than -0.7, and the fourth condition will be satisfied. However, if the character points mostly upwards or downwards (like (0.5, 1) or (0.5, -1)), then only the first or second conditions will be satisfied, respectively.

So, yes, the third and fourth conditions can be reached, but it depends on the input direction vector (are you pressing up, down, left, or right). If the vector is mostly horizontal, the third or fourth conditions will be met. If it's mostly vertical, only the first or second conditions will be satisfied.

Collapse
 
saleewisdom profile image
SaleeWisdom •

thank you for this great tutorial!
i mean,if u want create a sandbox survival game tutorial? like rimworld?just a small suggestion.

Collapse
 
saleewisdom profile image
SaleeWisdom •

Hi, thanks for u post

Read next

nikl profile image

Ask Anything in VS Code now for Development!

Nik L. -

msnmongare profile image

Essential Use Cases to Master API Development and Integration

Sospeter Mong'are -

mukilan_palanichamy_ecaa5 profile image

My journey in competitive programming

Mukilan Palanichamy -

rawas_aditya profile image

Understanding the Barrel Pattern in JavaScript/TypeScript

Aditya Rawas -