How do I get enemies to avoid getting stuck behind each other?

Audiobellum

So in my game, enemies can chase down the player via pathfinding across the navigation mesh. They only do this when they can't see the player anymore. When they spot the player again, they go back into the shoot state where they shoot at the player. The problem I have is that sometimes the chasing enemies will end up getting stuck behind the enemies in the shoot state. Do you know of any solution to this? Is there anyway to get enemies to avoid each other which chasing down the player?

There's a YouTube tutorial on this issue but, it could be updated. Check out the multiple enemies part( it's time stamped).

I'm only bringing up this YouTube video to show that I know there's a solution to the problem I have; I just want to know how it would work in the latest version of Godot( the video is from 2022).

kuligs2

Audiobellum well instead of pondering, did you try what he did in the video? I dont remember navigation agent changes since 4.2 version, so it might be the same as the video..

Audiobellum

kuligs2
I tried to do what the video did but, it didn't work for me. It totally broke my project but, I don't think it's the fault of the video. It's because I allowed ChatGPT to "update" follow_path() to the point that I can't immediately understand how it works by looking at it, which makes it hard for me to update it without breaking. Here's what I got:

func follow_path(delta: float, move_speed: float):
	var next_location = parent.nav_agent.get_next_path_position()
	var current_location = parent.global_transform.origin
	
	# Horizontal steering only
	var desired = (next_location - current_location).normalized() * move_speed
	desired.y = 0.0

	# Smooth steering on XZ plane
	var current_h = Vector3(parent.velocity.x, 0, parent.velocity.z)
	var target_h = current_h.move_toward(Vector3(desired.x, 0, desired.z), 8 * delta)

	# Tell the NavigationAgent3D what velocity we *want*
	parent.nav_agent.set_velocity(target_h)

	# Read the last computed (avoidance-adjusted) safe velocity from the agent (fallback to target_h if not ready)
	var adjusted_velocity = parent._nav_safe_velocity if ("_nav_safe_velocity" in parent) and parent._nav_safe_velocity.length() > 0.0001 else target_h

	# Apply it
	parent.velocity.x = adjusted_velocity.x
	parent.velocity.z = adjusted_velocity.z

	# Let gravity_force() handle velocity.y
	parent.move_and_slide()

	# Smooth rotation instead of snapping
	if adjusted_velocity.length() > 0.1:
		var target_dir = Vector3(adjusted_velocity.x, 0, adjusted_velocity.z).normalized()
		var current_dir = -parent.global_transform.basis.z
		var lerped_dir = current_dir.lerp(target_dir, 6 * delta).normalized()
		
		parent.look_at(parent.global_position + lerped_dir, Vector3.UP)

That's what the function looked like before I tried to follow the video. It's my fault. I've been relying on ChatGPT too much, ever since I was no longer allowed to take medication for my ADHD. I'm going to simplify follow_path() function and then follow the video probably. The video could still be outdated but, I wouldn't know. Sometimes it's more important to have code I understand, than for me to have code that "works" and this is one of those times.😔

YolloY

Click to reveal Click to hide

func follow_path(delta: float, move_speed: float):
var next_location = parent.nav_agent.get_next_path_position()
var current_location = parent.global_transform.origin

var direction = (next_location - current_location).normalized()
direction.y = 0.0  # Only horizontal movement is considered


var speed_factor = clamp(current_location.distance_to(next_location) / 10.0, 0.5, 1.0)
var desired = direction * move_speed * speed_factor

   
var current_h = Vector3(parent.velocity.x, 0, parent.velocity.z)
var target_h = current_h.linear_interpolate(Vector3(desired.x, 0, desired.z), 8 * delta)


parent.nav_agent.set_velocity(target_h)


var adjusted_velocity = parent._nav_safe_velocity if "_nav_safe_velocity" in parent and parent._nav_safe_velocity.length() > 0.0001 else target_h

  
parent.velocity.x = adjusted_velocity.x
parent.velocity.z = adjusted_velocity.z

 
parent.gravity_force()


var result = parent.move_and_collide(parent.velocity * delta)
if result.is_valid():
  
    parent.translate(result.remainder)


if adjusted_velocity.length() > 0.1:
    var target_dir = Vector3(adjusted_velocity.x, 0, adjusted_velocity.z).normalized()
    var current_dir = -parent.global_transform.basis.z
    var lerped_dir = current_dir.linear_interpolate(target_dir, 6 * delta).normalized()
    parent.look_at(parent.global_position + lerped_dir, Vector3.UP)!<

Audiobellum

YolloY

Thanks. Still, I should update you on what's going on. I went to ChatGPT again, they gave me a solution that didn't destroy my project like they did last time. However, their solution seem to have done absolutely nothing when I tested it or at least to my eyes. ChatGPT told me to place nav_agent.connect("velocity_computed", Callable(self, "_on_nav_velocity_computed")) in the parent's _ready() function and then told me to put this function in the parent:

var _nav_safe_velocity: Vector3 = Vector3.ZERO

func _on_nav_velocity_computed(safe_velocity: Vector3) -> void:
	_nav_safe_velocity = safe_velocity

According to ChatGPT, my follow_path() already uses this "logic" because it has this line:

var adjusted_velocity = parent._nav_safe_velocity if ("_nav_safe_velocity" in parent) and parent._nav_safe_velocity.length() > 0.0001 else target_h

What would help me is if I could recognize if my follow_path() has a variable like new_velocity, as shown in the video tutorial. The only similiar variable I have is the desired variable. However, even then, the desired variable doesn't get past into the set_velocity() function parameter directly thanks to current_h and target_h; leading to target_h getting placed inside the set_velocity() function.
However, after watching the video again, I don't think any of that is supposed to matter. What should matter is that function for the velocity computed function should look like the one in the video, or at least that's my interpretation of it. So that's what I did.
Now my _on_nav_velocity_computed() function looks like this:

func _on_nav_velocity_computed(safe_velocity: Vector3) -> void:
	velocity = velocity.move_toward(safe_velocity,.23)
	move_and_slide()

Now I've got the same problem that "broke" the game all over again. Enemies are now moving in states that don't require movement.😵

The good news is, I'm closer to understanding what the problem is or isn't. Originally, I though the problem is that I connected the velocity computed signal to my enemy's state base class( which means that every state would inherit a connection to the signal). Now I'm certain that it doesn't matter where the signal is connected; it's still going to cause the exact same problems for me.

Edit: So I updated the _on_nav_velocity_computed() function again to look like this:


func _on_nav_velocity_computed(safe_velocity: Vector3) -> void:
	velocity = safe_velocity

What's good about this, is that it didn't cause all my states to behave strange. However, it doesn't seem to make a different. The enemies aren't avoiding each other.

Edit again: It seemed to work when I increased "Radius". Here's the tutorial that helped.

I'm not completely satisfied with the results yet. I'm going to go revisit some of the code ChatGPT gave me just to see something.

Edit more time: Okay. Remember when I talked about how ChatGPT gave me this:

func _on_nav_velocity_computed(safe_velocity: Vector3) -> void:
	_nav_safe_velocity = safe_velocity

Apparently, that works too. LOL! Yeah, I think I'm satisfied with the solution for now. Anyway, thanks to everyone who replied to me. 🙂