add bug mesh - colorize flowfield - very simple enemy - and first test with multimesh

swarm_engine/flow_field_navigation/flow_field_cell.gd

@@ -1,11 +1,31 @@
 extends Resource
 class_name FlowFieldCell
 
-var position:Vector3 = Vector3(0.0, 0.0, 0.0)
-var flow_direction:Vector3 = Vector3(randf(), 0.0, randf())
+@export var cell_size: float = 1.0
+@export var position: Vector3 = Vector3.ZERO
+var flow_direction: Vector3 = Vector3.ZERO
+var is_target:bool = false
+
+
+func update(targetPos: Vector3):
+	if is_target:
+		flow_direction = Vector3.ZERO
+		return
+	
+	if targetPos != position:
+		flow_direction = (targetPos - position).normalized() * (cell_size/2)
+	else:
+		flow_direction = Vector3.ZERO
 
 func debug_process() -> void:
 	if flow_direction.length() > 0.0:
-		DebugDraw3D.draw_arrow(position, position + flow_direction, Color(1,1,1,1), 0.1)
+		var arrow_color = get_direction_color(flow_direction.normalized())
+		DebugDraw3D.draw_arrow(position, position + flow_direction, arrow_color, 0.1)
 	else:
-		DebugDraw3D.draw_sphere(position, .05)
+		DebugDraw3D.draw_sphere(position, 0.05)
+
+func get_direction_color(direction: Vector3) -> Color:
+	var angle = atan2(direction.z, direction.x)
+	var hue = (angle / (2.0 * PI)) + 0.5
+
+	return Color.from_hsv(hue, 1.0, 1.0)

swarm_engine/flow_field_navigation/flow_field_navigation.gd

@@ -1,4 +1,8 @@
 extends Node3D
+class_name FlowFieldNav
+
+@onready var player: Player = %player
+
 
 @export_group("Debug")
 @export var debugVisu: bool = true
@@ -11,10 +15,27 @@ extends Node3D
 var _cells: Dictionary
 var grid_offset: Vector3
 
+var target_position: Vector3
+var target_cell: FlowFieldCell
+
+var lines: PackedVector3Array
+
 func _ready() -> void:
 	var half_size = (grid_size * cell_size) * 0.5
 	grid_offset = Vector3(-half_size + (cell_size * 0.5), 0, -half_size + (cell_size * 0.5))
 	create_grid()
+	
+		# Vertikale Linien
+	for x in range(grid_size + 1):
+		var pos_x = x * cell_size + grid_offset.x - (cell_size * 0.5)
+		lines.append(Vector3(pos_x, 0, grid_offset.z - (cell_size * 0.5)))
+		lines.append(Vector3(pos_x, 0, grid_offset.z + grid_size * cell_size - (cell_size * 0.5)))
+	
+	# Horizontale Linien
+	for z in range(grid_size + 1):
+		var pos_z = z * cell_size + grid_offset.z - (cell_size * 0.5)
+		lines.append(Vector3(grid_offset.x - (cell_size * 0.5), 0, pos_z))
+		lines.append(Vector3(grid_offset.x + grid_size * cell_size - (cell_size * 0.5), 0, pos_z))
 
 func create_grid() -> void:
 	_cells.clear()
@@ -24,48 +45,36 @@ func create_grid() -> void:
 			var world_x = x * cell_size + grid_offset.x
 			var world_z = z * cell_size + grid_offset.z
 			cell.position = Vector3(world_x, 0, world_z)
+			cell.cell_size = cell_size
 			_cells[Vector3(x, 0, z)] = cell  # Dictionary mit Grid-Koordinaten als Key
 
 
 func _process(delta: float) -> void:
+	target_position = Vector3(player.position.x, 0, player.position.z)
+	var new_target_cell = get_cell_from_pos(target_position)
+	if target_cell != null and target_cell != new_target_cell:
+		target_cell.is_target = false
+		new_target_cell.is_target = true
+		target_cell = new_target_cell
+	else:
+		target_cell = new_target_cell
+		target_cell.is_target = true
+	
 	if debugVisu:
 		_debug_draw_grid()
 		for cell in _cells.values():
 			cell.debug_process()
+			
+	for cell in _cells.values():
+		cell.update(target_position)
 
 func _debug_draw_grid() -> void:
-	for x in range(grid_size + 1):
-		var pos_x = x * cell_size + grid_offset.x - (cell_size * 0.5)
-		DebugDraw3D.draw_line(Vector3(pos_x, 0, grid_offset.z - (cell_size * 0.5)), Vector3(pos_x, 0, grid_offset.z + grid_size * cell_size - (cell_size * 0.5)), line_color)
-
-	for z in range(grid_size + 1):
-		var pos_z = z * cell_size + grid_offset.z - (cell_size * 0.5)
-		DebugDraw3D.draw_line(Vector3(grid_offset.x - (cell_size * 0.5), 0, pos_z), Vector3(grid_offset.x + grid_size * cell_size - (cell_size * 0.5), 0, pos_z), line_color)
+	DebugDraw3D.draw_lines(lines, line_color)
 
 
-# Gibt die Zelle basierend auf einer Weltposition zurück
 func get_cell_from_pos(world_pos: Vector3) -> FlowFieldCell:
 	var grid_x = int((world_pos.x - grid_offset.x) / cell_size)
 	var grid_z = int((world_pos.z - grid_offset.z) / cell_size)
 	var cell_pos = Vector3(grid_x, 0, grid_z)
 
 	return _cells.get(cell_pos, null)
-
-
-# Raycast zur Bestimmung der Zelle unter dem Mauszeiger
-func _input(event):
-	if event is InputEventMouseButton and event.pressed:
-		var camera = get_viewport().get_camera_3d()
-		var from = camera.project_ray_origin(get_viewport().get_mouse_position())
-		var to = from + camera.project_ray_normal(get_viewport().get_mouse_position()) * 1000
-		
-		var space_state = get_world_3d().direct_space_state
-		var query = PhysicsRayQueryParameters3D.create(from, to)
-		var result = space_state.intersect_ray(query)
-		
-		if result.has("position"):
-			var cell = get_cell_from_pos(result["position"])
-			if cell:
-				print("Zelle an", cell.position, ":", cell.flow_direction)
-			else:
-				print("Keine Zelle gefunden!")