Void spreading enemy: Add ingesting state

In TileMapCover: Report the nodes as they are being consumed. And fix
the function documentation comment, previously it was also returning
true or false if nodes (not tiles) were consumed.

In the enemy new ingesting state, it does nothing more than waiting.
Transition to this state if the metadata of a consumed node says to be
ingested, and set the waiting to that amount of time.

Also emit particles when not the enemy is not moving. The previous
solution for emitting particles when not consuming stuff was
distance-based. Now if the enemy is standing in the new INGESTING state,
nothing would be displayed.

Author: manuq

scenes/quests/lore_quests/quest_002/1_void_runner/components/tile_map_cover.gd

@@ -116,8 +116,8 @@ func _ready() -> void:
 
 ## Cover all [param cells] with [member terrain_name], hiding any nodes in those cells which are
 ## direct children of [member consumable_node_holders].
-## Return true if any cells were consumed.
-func consume_cells(cells: Array[Vector2i], immediate: bool = false) -> bool:
+## Return true if any nodes were consumed.
+func consume_cells(cells: Array[Vector2i], immediate: bool = false) -> Array[Node2D]:
 	for i in range(cells.size() - 1, -1, -1):
 		var c: Vector2i = cells[i]
 
@@ -128,35 +128,44 @@ func consume_cells(cells: Array[Vector2i], immediate: bool = false) -> bool:
 	if cells:
 		set_cells_terrain_connect(cells, terrain_set, _terrain_id)
 
+		var consumed_nodes := [] as Array[Node2D]
 		for cell in cells:
-			consume(cell, immediate)
-		return true
-	return false
+			var nodes := consume(cell, immediate)
+			consumed_nodes.append_array(nodes)
+		return consumed_nodes
+	return []
 
 
 ## Hide all nodes in cell [param coord] which are direct children of
 ## [member consumable_node_holders].
-func consume(coord: Vector2i, immediate: bool = false) -> void:
+func consume(coord: Vector2i, immediate: bool = false) -> Array[Node2D]:
 	if coord not in _unconsumed_nodes:
-		return
+		return []
+
+	var consumed_nodes := [] as Array[Node2D]
 
 	var nodes: Array = _unconsumed_nodes[coord]
 	_unconsumed_nodes.erase(coord)
 	# TODO: store previous modulate.a to restore in uncover_all()
 	if immediate:
 		for node: Node2D in nodes:
 			node.modulate.a = 0.0
+			consumed_nodes.append(node)
 	else:
 		var tween := create_tween().set_parallel(true)
 		for node: Node2D in nodes:
 			tween.tween_property(node, "modulate:a", 0.0, _DURATION).set_ease(Tween.EASE_OUT)
-		await tween.finished
+			tween.finished.connect(_on_consumed_node_tween_finished.bind(node))
+			consumed_nodes.append(node)
 
-	for node: Node2D in nodes:
-		# TODO: also store original visibility and process mode
-		node.visible = false
-		node.process_mode = Node.PROCESS_MODE_DISABLED
 	_consumed_nodes[coord] = nodes
+	return consumed_nodes
+
+
+func _on_consumed_node_tween_finished(node: Node2D) -> void:
+	## TODO: also store original visibility and process mode
+	node.visible = false
+	node.process_mode = Node.PROCESS_MODE_DISABLED
 
 
 ## Clear this layer, and reveal all previously-"consumed" nodes, with an animation.

scenes/quests/lore_quests/quest_002/1_void_runner/components/void_spreading_enemy.gd

@@ -9,6 +9,8 @@ enum State {
 	IDLE,
 	## The void is chasing the player
 	CHASING,
+	## The void is busy ingesting something else, not the player for now
+	INGESTING,
 	## The void has engulfed the player
 	CAUGHT,
 	## The void has been defeated
@@ -28,6 +30,7 @@ const NEIGHBORS := [
 ]
 
 const IDLE_EMIT_DISTANCE := sqrt(2 * (64.0 ** 2))
+const IDLE_EMIT_TIME := 0.4
 
 @export var void_layer: TileMapCover
 
@@ -42,6 +45,7 @@ var state := State.IDLE:
 
 var _last_position: Vector2
 var _distance_since_emit: float = 0.0
+var _time_since_emit: float = 0.0
 var _live_particles: int = 0
 
 @onready var path_walk_behavior: PathWalkBehavior = %PathWalkBehavior
@@ -73,6 +77,9 @@ func _set_state(new_state: State) -> void:
 		State.CHASING:
 			path_walk_behavior.process_mode = Node.PROCESS_MODE_DISABLED
 			follow_walk_behavior.process_mode = Node.PROCESS_MODE_INHERIT
+		State.INGESTING:
+			path_walk_behavior.process_mode = Node.PROCESS_MODE_DISABLED
+			follow_walk_behavior.process_mode = Node.PROCESS_MODE_DISABLED
 		State.DEFEATED:
 			path_walk_behavior.process_mode = Node.PROCESS_MODE_DISABLED
 			follow_walk_behavior.process_mode = Node.PROCESS_MODE_DISABLED
@@ -99,6 +106,7 @@ func defeat() -> void:
 func _process(_delta: float) -> void:
 	if state == State.DEFEATED:
 		return
+	_time_since_emit += _delta
 	_distance_since_emit += (position - _last_position).length()
 	_last_position = position
 
@@ -111,12 +119,26 @@ func _process(_delta: float) -> void:
 	for neighbor: int in NEIGHBORS:
 		coords.append(void_layer.get_neighbor_cell(coord, neighbor))
 
-	var consumed := void_layer.consume_cells(coords)
-	if consumed or _distance_since_emit >= IDLE_EMIT_DISTANCE:
+	var consumed_nodes := void_layer.consume_cells(coords)
+	if (
+		consumed_nodes
+		or _distance_since_emit >= IDLE_EMIT_DISTANCE
+		or _time_since_emit >= IDLE_EMIT_TIME
+	):
 		_emit_particles()
 
+	if state == State.INGESTING:
+		return
+	for node in consumed_nodes:
+		if node.has_meta(&"ingest_time"):
+			var previous_state := state
+			state = State.INGESTING
+			await get_tree().create_timer(node.get_meta(&"ingest_time")).timeout
+			state = previous_state
+
 
 func _emit_particles() -> void:
+	_time_since_emit = 0
 	_distance_since_emit = 0
 
 	var particles: GPUParticles2D = VOID_PARTICLES.instantiate()