Do you know to make any a cover system for an enemy AI?

Audiobellum

Do you guys know to make any a cover system for an enemy AI in a first person shooter?
I've been trying to figure it but, I keep failing. I ask ChatGPT for help and it doesn't work out for me. I've search Youtube high and low for a tutorial but, all I got was a video titled "Godot 4. 3D Enemy Shooting and Cover system" by Youtuber Raku Nana; I'll link it right here:

I assume the video has good infromation in it but, it seems unscripted and difficult to follow.
It's easier to come up with code that tells the enemy where to find the nearest cover and I'll even share with you what I've got right here:

func nearest_available_cover():
	var covers = get_tree().get_nodes_in_group("Cover")
	var closest_cover = null
	var min_distance_squared = INF # Use squared distance for efficiency
	var my_position = global_transform.origin
	for cover : Cover_Area in covers:  # Check if the cover is valid
		if not is_instance_valid(cover) or cover == self:
			continue
		var their_position = cover.global_transform.origin
		var distance_squared = my_position.distance_squared_to(their_position)
		# Check if this is the new closest object
		if distance_squared < min_distance_squared:
			min_distance_squared = distance_squared
			closest_cover = cover            
	return closest_cover

I've even had some code in the cover to helps it to communicate to the enemy that it's safe and available( though it's function isn't being called in the current iteration of the nearest_available_cover() function). So here's what I find challenging.

Getting the enemy To move to available cover that's away from the player.

Getting the enemy to avoid moving to cover that other enemies are moving towards or talking.
I don't even know where to start when it comes to solving number 2. I've only showed one function from my enemy's code but, everything is a bit more complex on my end; I'm working with a node based finite state machine I'm trying to take advantage of it as much as possible.
The cover points I use are Area3d. I'm not sure if you anyone here needs to see the script for it but, here it is anyway:

extends Area3D

class_name Cover_Area

@onready var mesh = $%MeshInstance3D
@onready var raycast : RayCast3D = $%RayCast3D

@export var cover_point_model_visibility = true

var safe = true
var player : CharacterBody3D = null
var available = true


func _ready():
	body_entered.connect(entered_cover)
	body_exited.connect(leave_cover)
	if cover_point_model_visibility == false:
		mesh.visible = false
	if get_tree().get_first_node_in_group("Player") != null:
		player = get_tree().get_first_node_in_group("Player")

# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta):
	pass


func safety():
	if player != null and is_instance_valid(player):
		raycast.look_at(player.global_transform.origin,Vector3.UP)
		if raycast.is_colliding():
			var target = raycast.get_collider()
			if target.is_in_group("Player"):
				safe = false
			elif target.is_in_group("Enemy"):
				raycast.add_exception(target)
			else:safe = true
		else:safe = true

func safe_and_available():
	if safe == true and available == true:
		return true
	else:
		return false

func entered_cover(body):
	if body.is_in_group("Enemy"):
		pass

func leave_cover(body):
	if body.is_in_group("Enemy"):
		pass

So can you help me to come up with any idea for the cover system? Any pseudo-code or links to helpful articles would be greatly appreciated. You can also go to ChatGPT, ask it for help and then share what it showed you if it's worth showing; perhaps it would be more helpful to you. Old games like Perfect Dark for the n64 had a solution to this problem; I wonder what it's like and how complex it was. 🤔

ArDanZ11

Audiobellum Don't use ChatGPT for stuff like that, it's code is gonna be really buggy.

From my personal experience, ChatGPT style AI is not actually that great, as it is not very fast, doesn't have the right answers, and is in all just trying to make it seem like AI is smarter that it is.

xyz

Audiobellum Start with less generalized solution. Determine all cover points in pre processing, either before the start of level or even edit them into level either manually or write a tool script. When it's time to take cover, get all of them in a range, discard ones that are too near to player, discard ones that are seen by the player (rayhits) and pick several nearest candidates, pathfind to all of them and pick the one with the shortest path.

But start by first defining what would actually constitute a cover point in the context of your gameplay.

xyz

ArDanZ11 You're not embracing the exponentials to a sufficient degree! 😃

Audiobellum

ArDanZ11
"Don't use ChatGPT for stuff like that, it's code is gonna be really buggy."
True but, it's been a helpful starting point for me when it comes to implementing some features. I've managed to fix some or most of the bugs it throws my way; it even helps me to fix some bugs as well.

"From my personal experience, ChatGPT style AI is not actually that great, as it is not very fast, doesn't have the right answers, and is in all just trying to make it seem like AI is smarter that it is."

I think I've had similar experiences but, only when it comes to asking it for complicated solutions and how to implement complex features. It does help to give it lots of information but, it doesn't make a difference most of the time or at least when it comes to this problem.

Audiobellum

xyz

"Start with less generalized solution"
Sounds like a good start; thinking about implementing this feature has felt overwelming.
"Determine all cover points in pre processing, either before the start of level or even edit them into level either manually or write a tool script."
Cover points I just Area3D nodes that I manually place into the level. They're all placed into a group called "cover". I've managed to successfully get the enemy to move to a piece of cover using pathfinding code and the nearest_available_cover() function but, I only did it in isolation; I never did it in the context of it's state machine.
I once had the nearest_available_cover() function call the cover's the safe_and_available() function, when deciding when to choose a cover; I've removed it for reasons I can't remember. The only problems I have( besides the ones I've already mentioned), is that I don't even which is the best way to communicate to the enemy that they've reached cover and should take cover.
I'm not sure if the Area3D scripts for the cover should play an active role in letting the enemy know that they've reached cover and should take cover or if the enemy should just "take cover" when it noticed that it's "close enough" to cover( via distance check or something).

xyz

Audiobellum Covers should be points, not areas. When an enemy reaches a designated cover point, they're in cover. Conceptualizing them as points makes many things you're confused about a lot easier to manage, for example it's easy to know at any time if a cover point already is or will be occupied by another enemy, thus can be skipped when deciding where to go for cover.