Improve Unit Movement and Prevent Overlapping

[rluders]

📌 Description

The movement system still needs improvements. Currently, units can overlap and do not follow formations.

🎯 Goals

• Improve integration with NavigationAgent3D.
• Create a collision avoidance system to prevent unit overlap.
• Implement formation movement to maintain unit positioning.

📂 Related Files

• entities/unit_entity.gd
• core/rts_controller.gd

✅ Acceptance Criteria

• Units cannot occupy the same space when moving.
• Units adjust around obstacles naturally.
• Unit formations function correctly.

[amitnos123]

I will look at how godot open rts implemented their movement.

[rluders]

Yeah, I think that we can take a lot of things from the Godot Open RTS. Ideally, I would say that we should be able to use this framework to re-create the same project using our components.

[amitnos123]

Let's change the unit from Kinematic Body to Area.
We don't need to simulate physics. Hence, we can use Area for less processing power.

Other people test with Godot physics. Area3D is faster then AABB detection.

[rluders]

Switching entirely to Area3D may reduce processing overhead, but it complicates movement since it lacks built-in collision handling. Given our need for precise positioning, obstacle avoidance, and formation movement, a hybrid approach remains the better solution.

Keeping KinematicBody3D for movement allows us to fully leverage NavigationAgent3D’s avoidance system, ensuring units don’t overlap while maintaining smooth navigation with move_and_collide(). This avoids the need for extra manual logic to handle collision avoidance.

Replacing KB3D entirely with Area3D would require custom handling of unit collisions and formation spacing, potentially negating its performance benefits. However, Jolt Physics in Godot 4.4 could improve performance, making KB3D more viable than before.

As always, I lean toward a hybrid or swappable approach, where users can choose between Area3D or KB3D based on their specific needs. Let me know if I’m missing something here!

[amitnos123]

I went over some code related to navigation in 3D.
According to Godot's documentation , the different to make navigation for Node3D and KB3D is the following:

• KB3D

func _on_velocity_computed(safe_velocity: Vector3):
	velocity = safe_velocity
	move_and_slide()

• Node3D

func _physics_process(delta):
	movement_delta = movement_speed * delta

func _on_velocity_computed(safe_velocity: Vector3) -> void:
	global_position = global_position.move_toward(global_position + safe_velocity, movement_delta)

In KB3D you have the function move_and_slide() that does the movement for you.
In Node3D you need to calculate the movement_delta and do the movement yourself.

I'm still trying to understand the Open RTS script on movement.
In general, they did similar to what is in the documentation.
They added stuck prevention, passive movement (been pushed by outside?) tracking, and filtered rotation direction.

[amitnos123]

I got an idea of how to implement formation.
It would made from a predefined scene made from Position3D nodes.
that each node describes a position for a unit.
Later we can then add script logic for expanding. If the scene was defined for 4 units, the expanding logic would make it so it fit for 8 or more as needed.

[rluders]

Some ideas for unit formation:

Ring Position Algorithm

func generate_move_position_array(target_position: Vector3, position_count: int) -> Array:
	var positions: Array = []

	if position_count == 0:
		return positions

	positions.append(target_position)

	if position_count == 1:
		return positions

	var ring_size := 2.2
	var ring := 0
	var position_index := 1

	while position_index < position_count:
		var ring_position_count := 3 + ring * 2

		for i in range(ring_position_count):
			var angle := i * TAU / ring_position_count
			var offset := Vector3(cos(angle), 0, sin(angle)) * ring_size * (ring + 1)
			var ring_position := target_position + offset

			positions.append(ring_position)
			position_index += 1

			if position_index >= position_count:
				break

		ring += 1

	return positions

Line formation

func generate_line_formation(center: Vector3, count: int, spacing: float = 2.0) -> Array:
	var positions: Array = []
	var half_width := (count - 1) * spacing / 2.0
	
	for i in range(count):
		var offset_x := -half_width + i * spacing
		var position := center + Vector3(offset_x, 0, 0)
		positions.append(position)

	return positions

Arrow/Triangle Formation

func generate_triangle_formation(center: Vector3, count: int, spacing: float = 2.0) -> Array:
	var positions: Array = []
	var current_row := 0
	var placed := 0

	while placed < count:
		var row_count := current_row + 1
		for i in range(row_count):
			if placed >= count:
				break
			var offset_x := (i - (row_count - 1) / 2.0) * spacing
			var offset_z := -current_row * spacing
			var pos := center + Vector3(offset_x, 0, offset_z)
			positions.append(pos)
			placed += 1
		current_row += 1

	return positions

V Formation

func generate_v_formation(center: Vector3, count: int, spacing: float = 2.0) -> Array:
	var positions: Array = []
	positions.append(center)  # Líder no centro

	for i in range(1, count):
		var side := 1 if i % 2 == 0 else -1  # Alterna entre esquerda e direita
		var offset := (i + 1) / 2 * spacing
		var pos := center + Vector3(side * offset, 0, -offset)
		positions.append(pos)

	return positions

[rluders]

A few more:

Column

func generate_column_formation(center: Vector3, count: int, spacing: float = 2.0) -> Array:
	var positions: Array = []
	for i in range(count):
		var offset_z := -i * spacing
		positions.append(center + Vector3(0, 0, offset_z))
	return positions

V Inverted

func generate_chevron_inverted(center: Vector3, count: int, spacing: float = 2.0) -> Array:
	var positions: Array = [center]
	for i in range(1, count):
		var side := 1 if i % 2 == 0 else -1
		var offset := (i + 1) / 2 * spacing
		var pos := center + Vector3(side * offset, 0, offset)  # abre para trás
		positions.append(pos)
	return positions

Square / Rectangle

func generate_rectangle_formation(center: Vector3, count: int, spacing: float = 2.0, columns: int = 4) -> Array:
	var positions: Array = []
	for i in range(count):
		var col := i % columns
		var row := i / columns
		var offset := Vector3((col - (columns - 1) / 2.0) * spacing, 0, -row * spacing)
		positions.append(center + offset)
	return positions

Semicircle

func generate_semicircle_formation(center: Vector3, count: int, radius: float = 4.0) -> Array:
	var positions: Array = []
	for i in range(count):
		var angle := lerp(-PI / 2, PI / 2, float(i) / (count - 1))
		var pos := center + Vector3(cos(angle) * radius, 0, sin(angle) * radius)
		positions.append(pos)
	return positions

Diagonal

func generate_diagonal_formation(center: Vector3, count: int, spacing: float = 2.0) -> Array:
	var positions: Array = []
	for i in range(count):
		var offset := Vector3(i * spacing, 0, -i * spacing)
		positions.append(center + offset)
	return positions

Random

func generate_random_spread(center: Vector3, count: int, radius: float = 5.0) -> Array:
	var positions: Array = []
	var rng := RandomNumberGenerator.new()
	rng.randomize()
	
	while positions.size() < count:
		var angle := rng.randf_range(0, TAU)
		var dist := rng.randf_range(0.5 * radius, radius)
		var offset := Vector3(cos(angle), 0, sin(angle)) * dist
		var candidate := center + offset
		positions.append(candidate)
	
	return positions

[rluders]

@amitnos123 few formation algorithms that we may want to use.

[amitnos123]

Nice !