path: root/apworld/client/textclient.gd

extends CanvasLayer

var tabs
var panel
var label
var entry
var is_open = false

var locations_overlay
var location_texture
var worldport_texture
var goal_texture

var tracker_tree
var tracker_loc_tree_item_by_id = {}
var tracker_port_tree_item_by_id = {}
var tracker_goal_tree_item = null
var tracker_object_by_index = {}

var worldports_tab
var worldports_tree
var port_tree_item_by_map = {}
var port_tree_item_by_map_port = {}

const kLocation = 0
const kWorldport = 1
const kGoal = 2


func _ready():
	process_mode = ProcessMode.PROCESS_MODE_ALWAYS
	layer = 2

	locations_overlay = RichTextLabel.new()
	locations_overlay.name = "LocationsOverlay"
	locations_overlay.offset_top = 220
	locations_overlay.offset_bottom = 720
	locations_overlay.offset_left = 20
	locations_overlay.anchor_right = 1.0
	locations_overlay.offset_right = -10
	locations_overlay.scroll_active = false
	locations_overlay.mouse_filter = Control.MOUSE_FILTER_IGNORE
	locations_overlay.texture_filter = CanvasItem.TEXTURE_FILTER_NEAREST
	add_child(locations_overlay)
	update_locations_visibility()

	tabs = TabContainer.new()
	tabs.name = "Tabs"
	tabs.offset_left = 100
	tabs.offset_right = 1820
	tabs.offset_top = 100
	tabs.offset_bottom = 980
	tabs.visible = false
	tabs.theme = preload("res://assets/themes/baseUI.tres")
	tabs.add_theme_font_size_override("font_size", 36)
	add_child(tabs)

	panel = MarginContainer.new()
	panel.name = "Text Client"
	panel.add_theme_constant_override("margin_top", 60)
	panel.add_theme_constant_override("margin_left", 60)
	panel.add_theme_constant_override("margin_right", 60)
	panel.add_theme_constant_override("margin_bottom", 60)
	tabs.add_child(panel)

	label = RichTextLabel.new()
	label.set_name("Label")
	label.scroll_following = true
	label.selection_enabled = true
	label.size_flags_horizontal = Control.SIZE_EXPAND_FILL
	label.size_flags_vertical = Control.SIZE_EXPAND_FILL
	label.push_font(preload("res://assets/fonts/Lingo2.ttf"))
	label.push_font_size(30)

	var entry_style = StyleBoxFlat.new()
	entry_style.bg_color = Color(0.9, 0.9, 0.9, 1)

	entry = LineEdit.new()
	entry.set_name("Entry")
	entry.add_theme_font_override("font", preload("res://assets/fonts/Lingo2.ttf"))
	entry.add_theme_font_size_override("font_size", 36)
	entry.add_theme_color_override("font_color", Color(0, 0, 0, 1))
	entry.add_theme_color_override("cursor_color", Color(0, 0, 0, 1))
	entry.add_theme_stylebox_override("focus", entry_style)
	entry.text_submitted.connect(text_entered)

	var tc_arranger = VBoxContainer.new()
	tc_arranger.add_child(label)
	tc_arranger.add_child(entry)
	tc_arranger.add_theme_constant_override("separation", 40)
	panel.add_child(tc_arranger)

	var tracker_margins = MarginContainer.new()
	tracker_margins.name = "Locations"
	tracker_margins.add_theme_constant_override("margin_top", 60)
	tracker_margins.add_theme_constant_override("margin_left", 60)
	tracker_margins.add_theme_constant_override("margin_right", 60)
	tracker_margins.add_theme_constant_override("margin_bottom", 60)
	tabs.add_child(tracker_margins)

	tracker_tree = Tree.new()
	tracker_tree.columns = 3
	tracker_tree.hide_root = true
	tracker_tree.add_theme_font_size_override("font_size", 24)
	tracker_tree.add_theme_color_override("font_color", Color(0.8, 0.8, 0.8, 1))
	tracker_tree.add_theme_constant_override("v_separation", 1)
	tracker_tree.item_edited.connect(_on_tracker_button_clicked)
	tracker_tree.set_column_expand(0, false)
	tracker_tree.set_column_expand(1, true)
	tracker_tree.set_column_expand(2, false)
	tracker_tree.set_column_custom_minimum_width(2, 200)
	tracker_margins.add_child(tracker_tree)

	worldports_tab = MarginContainer.new()
	worldports_tab.name = "Worldports"
	worldports_tab.add_theme_constant_override("margin_top", 60)
	worldports_tab.add_theme_constant_override("margin_left", 60)
	worldports_tab.add_theme_constant_override("margin_right", 60)
	worldports_tab.add_theme_constant_override("margin_bottom", 60)
	tabs.add_child(worldports_tab)
	tabs.set_tab_hidden(2, true)

	worldports_tree = Tree.new()
	worldports_tree.columns = 2
	worldports_tree.hide_root = true
	worldports_tree.theme = preload("res://assets/themes/baseUI.tres")
	worldports_tree.add_theme_font_size_override("font_size", 24)
	worldports_tab.add_child(worldports_tree)

	var runtime = global.get_node("Runtime")
	var location_image = Image.new()
	location_image.load_png_from_buffer(runtime.read_path("assets/location.png"))
	location_texture = ImageTexture.create_from_image(location_image)

	var worldport_image = Image.new()
	worldport_image.load_png_from_buffer(runtime.read_path("assets/worldport.png"))
	worldport_texture = ImageTexture.create_from_image(worldport_image)

	var goal_image = Image.new()
	goal_image.load_png_from_buffer(runtime.read_path("assets/goal.png"))
	goal_texture = ImageTexture.create_from_image(goal_image)


func _input(event):
	if global.loaded and event is InputEventKey and event.pressed:
		if event.keycode == KEY_TAB and !Input.is_key_pressed(KEY_SHIFT):
			if !get_tree().paused:
				is_open = true
				get_tree().paused = true
				Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
				tabs.visible = true
				entry.grab_focus()
				get_viewport().set_input_as_handled()
			else:
				dismiss()
		elif event.keycode == KEY_ESCAPE:
			if is_open:
				dismiss()
				get_viewport().set_input_as_handled()


func dismiss():
	if is_open:
		get_tree().paused = false
		Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
		tabs.visible = false
		is_open = false


func parse_printjson(text):
	label.append_text("[p]" + text + "[/p]")


func text_entered(text):
	var ap = global.get_node("Archipelago")
	var cmd = text.trim_suffix("\n")
	entry.text = ""
	if OS.is_debug_build():
		if cmd.begins_with("/tp_map "):
			var new_map = cmd.substr(8)
			global.map = new_map
			global.sets_entry_point = false
			switcher.switch_map("res://objects/scenes/%s.tscn" % new_map)
			return

	ap.client.say(cmd)


func update_locations(reset_locations = true):
	var ap = global.get_node("Archipelago")
	var gamedata = global.get_node("Gamedata")

	locations_overlay.clear()
	locations_overlay.push_font(preload("res://assets/fonts/Lingo2.ttf"))
	locations_overlay.push_font_size(24)
	locations_overlay.push_color(Color(0.9, 0.9, 0.9, 1))
	locations_overlay.push_outline_color(Color(0, 0, 0, 1))
	locations_overlay.push_outline_size(2)

	var locations = []
	for location_id in ap.client._accessible_locations:
		if not ap.client._checked_locations.has(location_id):
			var location_name = gamedata.location_name_by_id.get(location_id, "(Unknown)")
			(
				locations
				. append(
					{
						"name": location_name,
						"type": kLocation,
						"id": location_id,
					}
				)
			)

	for port_id in ap.client._accessible_worldports:
		if not ap.client._checked_worldports.has(port_id):
			var port_name = gamedata.get_worldport_display_name(port_id)
			(
				locations
				. append(
					{
						"name": port_name,
						"type": kWorldport,
						"id": port_id,
					}
				)
			)

	locations.sort_custom(func(a, b): return a["name"] < b["name"])

	if ap.client._goal_accessible:
		var location_name = gamedata.ending_display_name_by_name[ap.kEndingNameByVictoryValue[
			ap.victory_condition
		]]
		(
			locations
			. push_front(
				{
					"name": location_name,
					"type": kGoal,
				}
			)
		)

	var count = 0
	for location in locations:
		if count < 18:
			locations_overlay.push_paragraph(HORIZONTAL_ALIGNMENT_RIGHT)
			locations_overlay.append_text(location["name"])
			locations_overlay.append_text(" ")
			if location["type"] == kLocation:
				locations_overlay.add_image(location_texture)
			elif location["type"] == kWorldport:
				locations_overlay.add_image(worldport_texture)
			elif location["type"] == kGoal:
				locations_overlay.add_image(goal_texture)
			locations_overlay.pop()
		count += 1

	if count > 18:
		locations_overlay.append_text("[p align=right][lb]...[rb][/p]")

	if reset_locations:
		reset_tracker_tab()

		var root_ti = tracker_tree.create_item(null)

		for location in locations:
			var loc_row = root_ti.create_child()
			loc_row.set_cell_mode(0, TreeItem.CELL_MODE_ICON)
			loc_row.set_selectable(0, false)
			loc_row.set_text(1, location["name"])
			loc_row.set_selectable(1, false)
			loc_row.set_cell_mode(2, TreeItem.CELL_MODE_CUSTOM)
			loc_row.set_text(2, "Show Path")
			loc_row.set_custom_as_button(2, true)
			loc_row.set_editable(2, true)
			loc_row.set_selectable(2, false)
			loc_row.set_text_alignment(2, HORIZONTAL_ALIGNMENT_CENTER)

			if location["type"] == kLocation:
				loc_row.set_icon(0, location_texture)
				tracker_loc_tree_item_by_id[location["id"]] = loc_row
			elif location["type"] == kWorldport:
				loc_row.set_icon(0, worldport_texture)
				tracker_port_tree_item_by_id[location["id"]] = loc_row
			elif location["type"] == kGoal:
				loc_row.set_icon(0, goal_texture)
				tracker_goal_tree_item = loc_row

			tracker_object_by_index[loc_row.get_index()] = location
	else:
		for loc_row in tracker_tree.get_root().get_children():
			loc_row.visible = false

		for location_id in tracker_loc_tree_item_by_id.keys():
			if (
				ap.client._accessible_locations.has(location_id)
				and not ap.client._checked_locations.has(location_id)
			):
				tracker_loc_tree_item_by_id[location_id].visible = true

		for port_id in tracker_port_tree_item_by_id.keys():
			if (
				ap.client._accessible_worldports.has(port_id)
				and not ap.client._checked_worldports.has(port_id)
			):
				tracker_port_tree_item_by_id[port_id].visible = true

		if tracker_goal_tree_item != null and ap.client._goal_accessible:
			tracker_goal_tree_item.visible = true


func update_locations_visibility():
	var ap = global.get_node("Archipelago")
	locations_overlay.visible = ap.show_locations


func _on_tracker_button_clicked():
	var edited_item = tracker_tree.get_edited()
	var edited_index = edited_item.get_index()

	if tracker_object_by_index.has(edited_index):
		var tracker_object = tracker_object_by_index[edited_index]
		var ap = global.get_node("Archipelago")
		var type_str = ""
		if tracker_object["type"] == kLocation:
			type_str = "location"
		elif tracker_object["type"] == kWorldport:
			type_str = "worldport"
		elif tracker_object["type"] == kGoal:
			type_str = "goal"
		ap.client.getLogicalPath(type_str, tracker_object.get("id", null))


func display_logical_path(object_type, object_id, paths):
	var ap = global.get_node("Archipelago")
	var gamedata = global.get_node("Gamedata")

	var location_name = "(Unknown)"
	if object_type == "location" and object_id != null:
		location_name = gamedata.location_name_by_id.get(object_id, "(Unknown)")
	elif object_type == "worldport" and object_id != null:
		location_name = gamedata.get_worldport_display_name(object_id)
	elif object_type == "goal":
		location_name = gamedata.ending_display_name_by_name[ap.kEndingNameByVictoryValue[
			ap.victory_condition
		]]

	label.append_text("[p]Path to %s:[/p]" % location_name)
	label.append_text("[ol]" + "\n".join(paths) + "[/ol]")

	panel.visible = true


func setup_worldports():
	tabs.set_tab_hidden(2, false)

	var root_ti = worldports_tree.create_item(null)

	var ports_by_map_id = {}
	var display_names_by_map_id = {}
	var display_names_by_port_id = {}

	var ap = global.get_node("Archipelago")
	var gamedata = global.get_node("Gamedata")
	for fpid in ap.port_pairings:
		var port = gamedata.objects.get_ports()[fpid]
		var room = gamedata.objects.get_rooms()[port.get_room_id()]

		if not ports_by_map_id.has(room.get_map_id()):
			ports_by_map_id[room.get_map_id()] = []

			var map = gamedata.objects.get_maps()[room.get_map_id()]
			display_names_by_map_id[map.get_id()] = map.get_display_name()

		ports_by_map_id[room.get_map_id()].append(fpid)
		display_names_by_port_id[fpid] = port.get_display_name()

	var sorted_map_ids = ports_by_map_id.keys().duplicate()
	sorted_map_ids.sort_custom(
		func(a, b): return display_names_by_map_id[a] < display_names_by_map_id[b]
	)

	for map_id in sorted_map_ids:
		var map_ti = root_ti.create_child()
		map_ti.set_text(0, display_names_by_map_id[map_id])
		map_ti.visible = false
		map_ti.collapsed = true
		port_tree_item_by_map[map_id] = map_ti
		port_tree_item_by_map_port[map_id] = {}

		var port_ids = ports_by_map_id[map_id]
		port_ids.sort_custom(
			func(a, b): return display_names_by_port_id[a] < display_names_by_port_id[b]
		)

		for port_id in port_ids:
			var port_ti = map_ti.create_child()
			port_ti.set_text(0, display_names_by_port_id[port_id])
			port_ti.set_text(1, gamedata.get_worldport_display_name(ap.port_pairings[port_id]))
			port_ti.visible = false
			port_tree_item_by_map_port[map_id][port_id] = port_ti

	update_worldports()


func update_worldports():
	var ap = global.get_node("Archipelago")

	for map_id in port_tree_item_by_map_port.keys():
		var map_visible = false

		for port_id in port_tree_item_by_map_port[map_id].keys():
			var ti = port_tree_item_by_map_port[map_id][port_id]
			ti.visible = ap.client._checked_worldports.has(port_id)

			if ti.visible:
				map_visible = true

		port_tree_item_by_map[map_id].visible = map_visible


func reset():
	locations_overlay.clear()
	tabs.set_tab_hidden(2, true)
	port_tree_item_by_map.clear()
	port_tree_item_by_map_port.clear()
	worldports_tree.clear()
	reset_tracker_tab()


func reset_tracker_tab():
	tracker_loc_tree_item_by_id.clear()
	tracker_port_tree_item_by_id.clear()
	tracker_goal_tree_item = null
	tracker_object_by_index.clear()
	tracker_tree.clear()