gai-godot-games/pathfinding-algorithms/scenes/mario-party/MarioPartyManagement.gd

extends Node2D

@onready var ground_layer: TileMapLayer = $GroundLayer
@onready var path_layer: TileMapLayer = $PathLayer
@onready var data_layer: TileMapLayer = $DataLayer
@onready var navigation_graph: MPNavigationGraph = $NavigationGraph
#
@onready var player: CharacterBody2D = $Player

var last_dice_result: int = 0
#
var global_transform_size: Vector2 = Vector2(0, 0)
#
const DIRECTIONS: Dictionary   = {
									 "up": Vector2(0, -1),
									 "down": Vector2(0, 1),
									 "left": Vector2(-1, 0),
									 "right": Vector2(1, 0)
								 }
var node_positions: Dictionary = {}


func _ready() -> void:
	global_transform_size = Vector2(16, 16) * data_layer.transform.get_scale()

	build_graph()

	# place the player at the first node
	var current_player_position: Vector2 = node_positions.keys()[0]
	player.global_position = local_to_world(current_player_position)

	# bring player to top
	player.z_index = 1

	roll_dice()

	player.finished_movement.connect(roll_dice)


func _physics_process(delta: float) -> void:
	if Input.is_action_just_pressed("draw_toggle_nodes") or Input.is_action_just_pressed("draw_toggle_edges"):
		navigation_graph.draw_nodes = !navigation_graph.draw_nodes
		navigation_graph.draw_edges = !navigation_graph.draw_edges
		navigation_graph.queue_redraw()

var dice_controls_min: int = 2
var dice_controls_max: int = 8


func roll_dice() -> void:
	last_dice_result = randi() % (dice_controls_max - dice_controls_min + 1) + dice_controls_min
	print("Dice result: ", last_dice_result)
	$ResultLabel.text = "Rolled a " + str(last_dice_result)

	# Find possible movement options
	var movement_options: Array[MPNavigationNode] = find_nodes_with_distance(world_to_local(player.global_position), last_dice_result)
	# visualize by spawning an indicator at each possible node, with a click event to move the player
	for node in movement_options:
		# res://scenes/mario-party/TileIndicator.tscn
		var indicator_scene: Node2D = preload("res://scenes/mario-party/TileIndicator.tscn").instantiate()
		indicator_scene.scale = Vector2(2, 2)
		var area_node: Area2D       = indicator_scene.get_node("area")
		area_node.set_data(node.position, "player_movement")
		area_node.indicator_clicked.connect(_on_indicator_clicked)
		indicator_scene.global_position = local_to_world(node.get_position())
		add_child(indicator_scene)
	
	# await get_tree().create_timer(1.0).timeout
	# var picked = movement_options[randi() % (len(movement_options))]
	# _on_indicator_clicked(picked.position, "player_movement")


func _on_indicator_clicked(pos: Vector2, type: String) -> void:
	print("Indicator clicked: ", type, " ", pos)
	if type == "player_movement":
		player.move_to(pos)
		# delete all indicators
		for child in get_children():
			if child is Node2D:
				var area_node: Area2D = child.get_node("area")
				if area_node != null:
					if area_node.get_type() == "player_movement":
						child.queue_free()


func local_to_world(location: Vector2) -> Vector2:
	return location * global_transform_size + global_transform_size / 2


func world_to_local(location: Vector2) -> Vector2:
	return (location - global_transform_size / 2) / global_transform_size


func build_graph() -> void:
	print("Identifying nodes")
	# Step 1: Place nodes at positions where is_tile is true
	for position in data_layer.get_used_cells():
		var tile_data: TileData = data_layer.get_cell_tile_data(position)
		var is_tile: bool       = tile_data.get_custom_data("is_tile")
		if is_tile:
			var node: MPNavigationNode  = navigation_graph.add_node(position.x, position.y)
			node_positions[position] = node
			var indicator_scene: Node2D = preload("res://scenes/mario-party/TileIndicator.tscn").instantiate()
			var area_node: Area2D       = indicator_scene.get_node("area")
			area_node.set_display_type("node")
			indicator_scene.global_position = local_to_world(position)
			add_child(indicator_scene)

	# Step 2: Connect nodes using flood-fill based on walkable tiles
	print("Connecting nodes")
	for position in node_positions.keys():
		connect_node(position)


func connect_node(start_position: Vector2) -> void:
	var start_node          = node_positions.get(Vector2i(start_position))
	var visited: Dictionary = {}
	visited[start_position] = true
	# print("Connecting node at ", start_position)

	# For each direction, perform flood-fill
	for dir_name in DIRECTIONS.keys():
		var direction     = DIRECTIONS[dir_name]
		var next_position = start_position + direction

		# print("Checking direction ", dir_name, " from ", start_position, " to ", next_position)

		# Ensure the first tile respects the direction
		if not is_valid_direction(next_position, dir_name):
			continue
		# print("Flood-fill in direction ", dir_name, " from ", next_position)

		# Perform flood-fill from the valid tile
		var connected_nodes: Array = flood_fill(next_position, visited)

		# Add connections between the start node and found nodes
		for target_position in connected_nodes:
			if target_position != start_position:
				if node_positions.has(Vector2i(target_position)):
					var target_node = node_positions.get(Vector2i(target_position))
					navigation_graph.add_connection(start_node, target_node)
					print(start_position, " --> ", target_position)


func flood_fill(start_position: Vector2, visited: Dictionary) -> Array:
	var stack: Array[Vector2]           = [start_position]
	var connected_nodes: Array[Vector2] = []

	while stack.size() > 0:
		var current_position = stack.pop_back()
		# print(" - Visiting ", current_position)

		# Skip if already visited
		if visited.has(current_position):
			continue

		visited[current_position] = true

		# Skip if not walkable
		var tile_data: TileData = data_layer.get_cell_tile_data(current_position)
		if tile_data == null:
			continue

		var is_walkable: bool = tile_data.get_custom_data("is_walkable")
		var is_tile: bool     = tile_data.get_custom_data("is_tile")
		if (not is_walkable) and (not is_tile):
			continue

		# If this position is a node, add it to the result
		if is_tile:
			# print(" - Found node tile at ", current_position)
			connected_nodes.append(current_position)

		# Add neighboring tiles to the stack if they respect the direction
		for dir_name in DIRECTIONS.keys():
			var direction         = DIRECTIONS[dir_name]
			var neighbor_position = current_position + direction

			if not visited.has(neighbor_position):
				if is_valid_direction(current_position, dir_name):
					stack.append(neighbor_position)

	return connected_nodes


func is_valid_direction(position: Vector2, required_dir: String) -> bool:
	var tile_data: TileData = data_layer.get_cell_tile_data(position)
	if tile_data == null:
		return false

	var is_walkable: bool = tile_data.get_custom_data("is_walkable")
	var walk_dir: String  = tile_data.get_custom_data("walk_dir")
	if walk_dir == "":
		walk_dir = "any"

	# print(" L ", position, " ", is_walkable, " ", walk_dir, " ", required_dir)

	# Check if the tile is walkable and allows movement in the required direction
	return is_walkable and (walk_dir == required_dir or walk_dir == "any")


# the first function that evaluates the finished graph
# it is given a starting position and a distance in integers, which represent the amount of nodes to travel to reach the target node(s)
# it will find any nodes that are the given distance away from the starting node and return them in an array
# distance here is the amount of nodes to travel, not the actual distance in pixels
# must use the MPNavigationNode class and the navigation_graph.get_connections(node: MPNavigationNode) function
func find_nodes_with_distance(start_position: Vector2, distance: int) -> Array[MPNavigationNode]:
	var start_node = node_positions.get(Vector2i(start_position))
	if start_node == null:
		print("Error: No node found at starting position ", start_position)
		return []

	# Initialize BFS
	var queue: Array                          = [[start_node, 0]]  # Each element is [node, current_distance]
	var visited: Dictionary                   = {start_node: true}
	var result_nodes: Array[MPNavigationNode] = []

	while queue.size() > 0:
		var current                        = queue.pop_front()
		var current_node: MPNavigationNode = current[0]
		var current_distance: int          = current[1]

		# If the target distance is reached, add the node to the result
		if current_distance == distance:
			result_nodes.append(current_node)
			continue  # Do not explore further from this node

		# If the current distance exceeds the target, stop exploring
		if current_distance > distance:
			break

		# Explore neighbors of the current node
		var neighbors: Array[MPNavigationNode] = navigation_graph.get_connections(current_node)
		for neighbor in neighbors:
			if not visited.has(neighbor):
				visited[neighbor] = true
				queue.append([neighbor, current_distance + 1])

	return result_nodes