client/Archipelago/manager.gd


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
pre { line-height: 125%; }
td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */doors {
  name: "Control Center Brown Door"
  type: CONTROL_CENTER_COLOR
  receivers: "Components/Doors/entry_1"
  control_center_color: "brown"
}
doors {
  name: "The Tree Gravestone"
  type: GRAVESTONE
  panels { room: "Main Area" name: "COLOR" }
  panels { room: "Main Area" name: "DAMAGE (1)" }
  panels { room: "Main Area" name: "DAMAGE (2)" }
  panels { room: "Main Area" name: "MEAL (1)" }
  panels { room: "Main Area" name: "MEAL (2)" }
  panels { room: "Main Area" name: "WALK (1)" }
  panels { room: "Main Area" name: "WALK (2)" }
  panels { room: "Main Area" name: "REST" }
  panels { room: "Main Area" name: "SLEEP" }
  panels { room: "Main Area" name: "JUMP (1)" }
  panels { room: "Main Area" name: "JUMP (2)" }
  panels { room: "Main Area" name: "DRIZZLE" }
  panels { room: "Main Area" name: "WADE" }
  panels { room: "Main Area" name: "GROW (1)" }
  panels { room: "Main Area" name: "GROW (2)" }
  panels { room: "Main Area" name: "GROW (3)" }
  panels { room: "Main Area" name: "GOOD (1)" }
  panels { room: "Main Area" name: "GOOD (2)" }
  panels { room: "Main Area" name: "GOOD (3)" }
  panels { room: "Main Area" name: "HOVER" }
  panels { room: "Main Area" name: "HAPPY (1)" }
  panels { room: "Main Area" name: "HAPPY (2)" }
  panels { room: "Main Area" name: "HAPPY (3)" }
  panels { room: "Main Area" name: "LIGHT (1)" }
  panels { room: "Main Area" name: "LIGHT (2)" }
  panels { room: "Main Area" name: "LIGHT (3)" }
  panels { room: "Main Area" name: "SMALL (1)" }
  panels { room: "Main Area" name: "SMALL (2)" }
  panels { room: "Main Area" name: "SMALL (3)" }
  panels { room: "Main Area" name: "SPRINKLE" }
  location_room: "Main Area"
  location_name: "Gravestone"
}
extends Node

const MOD_VERSION = 1

var SCRIPT_client
var SCRIPT_keyboard
var SCRIPT_locationListener
var SCRIPT_uuid
var SCRIPT_victoryListener

var ap_server = ""
var ap_user = ""
var ap_pass = ""
var connection_history = []

var client
var keyboard

var _localdata_file = ""
var _last_new_item = -1
var _batch_locations = false
var _held_locations = []
var _held_location_scouts = []
var _location_scouts = {}
var _item_locks = {}
var _inverse_item_locks = {}
var _held_letters = {}
var _letters_setup = false

const kSHUFFLE_LETTERS_VANILLA = 0
const kSHUFFLE_LETTERS_UNLOCKED = 1
const kSHUFFLE_LETTERS_PROGRESSIVE = 2
const kSHUFFLE_LETTERS_VANILLA_CYAN = 3
const kSHUFFLE_LETTERS_ITEM_CYAN = 4

const kLETTER_BEHAVIOR_VANILLA = 0
const kLETTER_BEHAVIOR_ITEM = 1
const kLETTER_BEHAVIOR_UNLOCKED = 2

const kCYAN_DOOR_BEHAVIOR_H2 = 0
const kCYAN_DOOR_BEHAVIOR_DOUBLE_LETTER = 1
const kCYAN_DOOR_BEHAVIOR_ITEM = 2

var cyan_door_behavior = kCYAN_DOOR_BEHAVIOR_H2
var daedalus_roof_access = false
var keyholder_sanity = false
var shuffle_control_center_colors = false
var shuffle_doors = false
var shuffle_letters = kSHUFFLE_LETTERS_VANILLA
var shuffle_symbols = false
var victory_condition = -1

signal could_not_connect
signal connect_status
signal ap_connected


func _init():
	# Read AP settings from file, if there are any
	if FileAccess.file_exists("user://ap_settings"):
		var file = FileAccess.open("user://ap_settings", FileAccess.READ)
		var data = file.get_var(true)
		file.close()

		if typeof(data) != TYPE_ARRAY:
			global._print("AP settings file is corrupted")
			data = []

		if data.size() > 0:
			ap_server = data[0]

		if data.size() > 1:
			ap_user = data[1]

		if data.size() > 2:
			ap_pass = data[2]

		if data.size() > 3:
			connection_history = data[3]


func _ready():
	client = SCRIPT_client.new()
	client.SCRIPT_uuid = SCRIPT_uuid

	client.connect("item_received", _process_item)
	client.connect("message_received", _process_message)
	client.connect("location_scout_received", _process_location_scout)
	client.connect("could_not_connect", _client_could_not_connect)
	client.connect("connect_status", _client_connect_status)
	client.connect("client_connected", _client_connected)

	add_child(client)

	keyboard = SCRIPT_keyboard.new()
	add_child(keyboard)


func saveSettings():
	# Save the AP settings to disk.
	var path = "user://ap_settings"
	var file = FileAccess.open(path, FileAccess.WRITE)

	var data = [
		ap_server,
		ap_user,
		ap_pass,
		connection_history,
	]
	file.store_var(data, true)
	file.close()


func saveLocaldata():
	# Save the MW/slot specific settings to disk.
	var dir = DirAccess.open("user://")
	var folder = "archipelago_data"
	if not dir.dir_exists(folder):
		dir.make_dir(folder)

	var file = FileAccess.open(_localdata_file, FileAccess.WRITE)

	var data = [
		_last_new_item,
	]
	file.store_var(data, true)
	file.close()


func connectToServer():
	_last_new_item = -1
	_batch_locations = false
	_held_locations = []
	_held_location_scouts = []
	_location_scouts = {}
	_letters_setup = false
	_held_letters = {}

	client.connectToServer(ap_server, ap_user, ap_pass)


func getSaveFileName():
	return "zzAP_%s_%d" % [client._seed, client._slot]


func disconnect_from_ap():
	client.disconnect_from_ap()


func get_item_id_for_door(door_id):
	return _item_locks.get(door_id, null)


func _process_item(item, index, from, flags, amount):
	var item_name = "Unknown"
	if client._item_id_to_name["Lingo 2"].has(item):
		item_name = client._item_id_to_name["Lingo 2"][item]

	var gamedata = global.get_node("Gamedata")

	var prog_id = null
	if _inverse_item_locks.has(item):
		for lock in _inverse_item_locks.get(item):
			if lock[1] != amount:
				continue

			if gamedata.progressive_id_by_ap_id.has(item):
				prog_id = lock[0]

			if gamedata.get_door_map_name(lock[0]) != global.map:
				continue

			var receivers = gamedata.get_door_receivers(lock[0])
			var scene = get_tree().get_root().get_node_or_null("scene")
			if scene != null:
				for receiver in receivers:
					var rnode = scene.get_node_or_null(receiver)
					if rnode != null:
						rnode.handleTriggered()

	var letter_id = gamedata.letter_id_by_ap_id.get(item, null)
	if letter_id != null:
		var letter = gamedata.objects.get_letters()[letter_id]
		if not letter.has_level2() or not letter.get_level2():
			_process_key_item(letter.get_key(), amount)

	if gamedata.symbol_item_ids.has(item):
		var player = get_tree().get_root().get_node_or_null("scene/player")
		if player != null:
			player.emit_signal("evaluate_solvability")

	# Show a message about the item if it's new.
	if index != null and index > _last_new_item:
		_last_new_item = index
		saveLocaldata()

		var player_name = "Unknown"
		if client._player_name_by_slot.has(float(from)):
			player_name = client._player_name_by_slot[float(from)]

		var item_color = colorForItemType(flags)

		var full_item_name = item_name
		if prog_id != null:
			var door = gamedata.objects.get_doors()[prog_id]
			full_item_name = "%s (%s)" % [item_name, door.get_name()]

		var message
		if from == client._slot:
			message = "Found [color=%s]%s[/color]" % [item_color, full_item_name]
		else:
			message = (
				"Received [color=%s]%s[/color] from %s" % [item_color, full_item_name, player_name]
			)

		global._print(message)

		global.get_node("Messages").showMessage(message)


func _process_message(message):
	parse_printjson_for_textclient(message)

	if (
		!message.has("receiving")
		or !message.has("item")
		or message["item"]["player"] != client._slot
	):
		return

	var item_name = "Unknown"
	var item_player_game = client._game_by_player[message["receiving"]]
	if client._item_id_to_name[item_player_game].has(int(message["item"]["item"])):
		item_name = client._item_id_to_name[item_player_game][int(message["item"]["item"])]

	var location_name = "Unknown"
	var location_player_game = client._game_by_player[message["item"]["player"]]
	if client._location_id_to_name[location_player_game].has(int(message["item"]["location"])):
		location_name = (client._location_id_to_name[location_player_game][int(
			message["item"]["location"]
		)])

	var player_name = "Unknown"
	if client._player_name_by_slot.has(message["receiving"]):
		player_name = client._player_name_by_slot[message["receiving"]]

	var item_color = colorForItemType(message["item"]["flags"])

	if message["type"] == "Hint":
		var is_for = ""
		if message["receiving"] != client._slot:
			is_for = " for %s" % player_name
		if !message.has("found") || !message["found"]:
			global.get_node("Messages").showMessage(
				(
					"Hint: [color=%s]%s[/color]%s is on %s"
					% [item_color, item_name, is_for, location_name]
				)
			)
	else:
		if message["receiving"] != client._slot:
			var sentMsg = "Sent [color=%s]%s[/color] to %s" % [item_color, item_name, player_name]
			#if _hinted_locations.has(message["item"]["location"]):
			#	sentMsg += " ([color=#fafad2]Hinted![/color])"
			global.get_node("Messages").showMessage(sentMsg)


func parse_printjson_for_textclient(message):
	var parts = []
	for message_part in message["data"]:
		if !message_part.has("type") and message_part.has("text"):
			parts.append(message_part["text"])
		elif message_part["type"] == "player_id":
			if int(message_part["text"]) == client._slot:
				parts.append(
					"[color=#ee00ee]%s[/color]" % client._player_name_by_slot[client._slot]
				)
			else:
				var from = float(message_part["text"])
				parts.append("[color=#fafad2]%s[/color]" % client._player_name_by_slot[from])
		elif message_part["type"] == "item_id":
			var item_name = "Unknown"
			var item_player_game = client._game_by_player[message_part["player"]]
			if client._item_id_to_name[item_player_game].has(int(message_part["text"])):
				item_name = client._item_id_to_name[item_player_game][int(message_part["text"])]

			parts.append(
				"[color=%s]%s[/color]" % [colorForItemType(message_part["flags"]), item_name]
			)
		elif message_part["type"] == "location_id":
			var location_name = "Unknown"
			var location_player_game = client._game_by_player[message_part["player"]]
			if client._location_id_to_name[location_player_game].has(int(message_part["text"])):
				location_name = client._location_id_to_name[location_player_game][int(
					message_part["text"]
				)]

			parts.append("[color=#00ff7f]%s[/color]" % location_name)
		elif message_part.has("text"):
			parts.append(message_part["text"])

	var textclient_node = global.get_node("Textclient")
	if textclient_node != null:
		textclient_node.parse_printjson("".join(parts))


func _process_location_scout(item_id, location_id, player, flags):
	_location_scouts[location_id] = {"item": item_id, "player": player, "flags": flags}

	var gamedata = global.get_node("Gamedata")
	var map_id = gamedata.map_id_by_name.get(global.map)

	var item_name = "Unknown"
	var item_player_game = client._game_by_player[float(player)]
	if client._item_id_to_name[item_player_game].has(item_id):
		item_name = client._item_id_to_name[item_player_game][item_id]

	var letter_id = gamedata.letter_id_by_ap_id.get(location_id, null)
	if letter_id != null:
		var letter = gamedata.objects.get_letters()[letter_id]
		var room = gamedata.objects.get_rooms()[letter.get_room_id()]
		if room.get_map_id() == map_id:
			var collectable = get_tree().get_root().get_node("scene").get_node_or_null(
				letter.get_path()
			)
			if collectable != null:
				collectable.setScoutedText(item_name)


func _client_could_not_connect():
	emit_signal("could_not_connect")


func _client_connect_status(message):
	emit_signal("connect_status", message)


func _client_connected(slot_data):
	var gamedata = global.get_node("Gamedata")

	_localdata_file = "user://archipelago_data/%s_%d" % [client._seed, client._slot]
	_last_new_item = -1

	if FileAccess.file_exists(_localdata_file):
		var ap_file = FileAccess.open(_localdata_file, FileAccess.READ)
		var localdata = []
		if ap_file != null:
			localdata = ap_file.get_var(true)
			ap_file.close()

		if typeof(localdata) != TYPE_ARRAY:
			print("AP localdata file is corrupted")
			localdata = []

		if localdata.size() > 0:
			_last_new_item = localdata[0]

	# Read slot data.
	cyan_door_behavior = int(slot_data.get("cyan_door_behavior", 0))
	daedalus_roof_access = bool(slot_data.get("daedalus_roof_access", false))
	keyholder_sanity = bool(slot_data.get("keyholder_sanity", false))
	shuffle_control_center_colors = bool(slot_data.get("shuffle_control_center_colors", false))
	shuffle_doors = bool(slot_data.get("shuffle_doors", false))
	shuffle_letters = int(slot_data.get("shuffle_letters", 0))
	shuffle_symbols = bool(slot_data.get("shuffle_symbols", false))
	victory_condition = int(slot_data.get("victory_condition", 0))

	# Set up item locks.
	_item_locks = {}

	if shuffle_doors:
		for door in gamedata.objects.get_doors():
			if (
				door.get_type() == gamedata.SCRIPT_proto.DoorType.STANDARD
				or door.get_type() == gamedata.SCRIPT_proto.DoorType.ITEM_ONLY
			):
				_item_locks[door.get_id()] = [door.get_ap_id(), 1]

		for progressive in gamedata.objects.get_progressives():
			for i in range(0, progressive.get_doors().size()):
				var door = gamedata.objects.get_doors()[progressive.get_doors()[i]]
				_item_locks[door.get_id()] = [progressive.get_ap_id(), i + 1]

		for door_group in gamedata.objects.get_door_groups():
			if (
				door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.CONNECTOR
				or door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.SHUFFLE_GROUP
			):
				for door in door_group.get_doors():
					_item_locks[door] = [door_group.get_ap_id(), 1]

	if shuffle_control_center_colors:
		for door in gamedata.objects.get_doors():
			if door.get_type() == gamedata.SCRIPT_proto.DoorType.CONTROL_CENTER_COLOR:
				_item_locks[door.get_id()] = [door.get_ap_id(), 1]

		for door_group in gamedata.objects.get_door_groups():
			if door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.COLOR_CONNECTOR:
				for door in door_group.get_doors():
					_item_locks[door] = [door_group.get_ap_id(), 1]

	if cyan_door_behavior == kCYAN_DOOR_BEHAVIOR_ITEM:
		for door_group in gamedata.objects.get_door_groups():
			if door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.CYAN_DOORS:
				for door in door_group.get_doors():
					if not _item_locks.has(door):
						_item_locks[door] = [door_group.get_ap_id(), 1]

	# Create a reverse item locks map for processing items.
	_inverse_item_locks = {}

	for door_id in _item_locks.keys():
		var lock = _item_locks.get(door_id)

		if not _inverse_item_locks.has(lock[0]):
			_inverse_item_locks[lock[0]] = []

		_inverse_item_locks[lock[0]].append([door_id, lock[1]])

	emit_signal("ap_connected")


func start_batching_locations():
	_batch_locations = true


func send_location(loc_id):
	if _batch_locations:
		_held_locations.append(loc_id)
	else:
		client.sendLocation(loc_id)


func scout_location(loc_id):
	if _location_scouts.has(loc_id):
		return _location_scouts.get(loc_id)

	if _batch_locations:
		_held_location_scouts.append(loc_id)
	else:
		client.scoutLocation(loc_id)

	return null


func stop_batching_locations():
	_batch_locations = false

	if not _held_locations.is_empty():
		client.sendLocations(_held_locations)
		_held_locations.clear()

	if not _held_location_scouts.is_empty():
		client.scoutLocations(_held_location_scouts)
		_held_location_scouts.clear()


func colorForItemType(flags):
	var int_flags = int(flags)
	if int_flags & 1:  # progression
		if int_flags & 2:  # proguseful
			return "#f0d200"
		else:
			return "#bc51e0"
	elif int_flags & 2:  # useful
		return "#2b67ff"
	elif int_flags & 4:  # trap
		return "#d63a22"
	else:  # filler
		return "#14de9e"


func get_letter_behavior(key, level2):
	if shuffle_letters == kSHUFFLE_LETTERS_UNLOCKED:
		return kLETTER_BEHAVIOR_UNLOCKED

	if [kSHUFFLE_LETTERS_VANILLA_CYAN, kSHUFFLE_LETTERS_ITEM_CYAN].has(shuffle_letters):
		if level2:
			if shuffle_letters == kSHUFFLE_LETTERS_VANILLA_CYAN:
				return kLETTER_BEHAVIOR_VANILLA
			else:
				return kLETTER_BEHAVIOR_ITEM
		else:
			return kLETTER_BEHAVIOR_UNLOCKED

	if not level2 and ["h", "i", "n", "t"].has(key):
		# This differs from the equivalent function in the apworld. Logically it is
		# the same as UNLOCKED since they are in the starting room, but VANILLA
		# means the player still has to actually pick up the letters.
		return kLETTER_BEHAVIOR_VANILLA

	if shuffle_letters == kSHUFFLE_LETTERS_PROGRESSIVE:
		return kLETTER_BEHAVIOR_ITEM

	return kLETTER_BEHAVIOR_VANILLA


func setup_keys():
	keyboard.load_seed()

	_letters_setup = true

	for k in _held_letters.keys():
		_process_key_item(k, _held_letters[k])

	_held_letters.clear()


func _process_key_item(key, level):
	if not _letters_setup:
		_held_letters[key] = max(_held_letters.get(key, 0), level)
		return

	keyboard.collect_remote_letter(key, level)