Client is starting to work!

11 files changed, 1107 insertions, 0 deletions

@@ -0,0 +1,378 @@
+extends Node
+
+const ap_version = {"major": 0, "minor": 6, "build": 3, "class": "Version"}
+
+var SCRIPT_uuid
+
+var _ws = WebSocketPeer.new()
+var _should_process = false
+var _initiated_disconnect = false
+var _try_wss = false
+var _has_connected = false
+
+var _datapackages = {}
+var _pending_packages = []
+var _item_id_to_name = {}  # All games
+var _location_id_to_name = {}  # All games
+var _item_name_to_id = {}  # Lingo 2 only
+var _location_name_to_id = {}  # Lingo 2 only
+
+var _remote_version = {"major": 0, "minor": 0, "build": 0}
+var _gen_version = {"major": 0, "minor": 0, "build": 0}
+
+var ap_server = ""
+var ap_user = ""
+var ap_pass = ""
+
+var _authenticated = false
+var _seed = ""
+var _team = 0
+var _slot = 0
+var _players = []
+var _player_name_by_slot = {}
+var _game_by_player = {}
+var _checked_locations = []
+var _received_items = []
+var _slot_data = {}
+
+signal could_not_connect
+signal connect_status
+signal client_connected
+signal item_received(item_id, index, player, flags)
+signal message_received(message)
+
+
+func _init():
+        global._print("Instantiated APClient")
+
+        # Read AP settings from file, if there are any
+        if FileAccess.file_exists("user://ap_datapackages"):
+                var file = FileAccess.open("user://ap_datapackages", FileAccess.READ)
+                var data = file.get_var(true)
+                file.close()
+
+                if typeof(data) != TYPE_DICTIONARY:
+                        global._print("AP datapackages file is corrupted")
+                        data = {}
+
+                _datapackages = data
+
+                processDatapackages()
+
+
+func _ready():
+        pass
+        #_ws.connect("connection_closed", _closed)
+        #_ws.connect("connection_failed", _closed)
+        #_ws.connect("server_disconnected", _closed)
+        #_ws.connect("connection_error", _errored)
+        #_ws.connect("connection_established", _connected)
+
+
+func _reset_state():
+        _should_process = false
+        _authenticated = false
+        _try_wss = false
+        _has_connected = false
+
+
+func _errored():
+        if _try_wss:
+                global._print("Could not connect to AP with ws://, now trying wss://")
+                connectToServer(ap_server, ap_user, ap_pass)
+        else:
+                global._print("AP connection failed")
+                _reset_state()
+
+                emit_signal(
+                        "could_not_connect",
+                        "Could not connect to Archipelago. Check that your server and port are correct. See the error log for more information."
+                )
+
+
+func _closed(_was_clean = true):
+        global._print("Connection closed")
+        _reset_state()
+
+        if not _initiated_disconnect:
+                emit_signal("could_not_connect", "Disconnected from Archipelago")
+
+        _initiated_disconnect = false
+
+
+func _connected(_proto = ""):
+        global._print("Connected!")
+        _try_wss = false
+
+
+func disconnect_from_ap():
+        _initiated_disconnect = true
+        _ws.close()
+
+
+func _process(_delta):
+        if _should_process:
+                _ws.poll()
+
+                var state = _ws.get_ready_state()
+                if state == WebSocketPeer.STATE_OPEN:
+                        if not _has_connected:
+                                _has_connected = true
+
+                                _connected()
+
+                        while _ws.get_available_packet_count():
+                                var packet = _ws.get_packet()
+                                global._print("Got data from server: " + packet.get_string_from_utf8())
+                                var json = JSON.new()
+                                var jserror = json.parse(packet.get_string_from_utf8())
+                                if jserror != OK:
+                                        global._print("Error parsing packet from AP: " + jserror.error_string)
+                                        return
+
+                                for message in json.data:
+                                        var cmd = message["cmd"]
+                                        global._print("Received command: " + cmd)
+
+                                        if cmd == "RoomInfo":
+                                                _seed = message["seed_name"]
+                                                _remote_version = message["version"]
+                                                _gen_version = message["generator_version"]
+
+                                                var needed_games = []
+                                                for game in message["datapackage_checksums"].keys():
+                                                        if (
+                                                                !_datapackages.has(game)
+                                                                or (
+                                                                        _datapackages[game]["checksum"]
+                                                                        != message["datapackage_checksums"][game]
+                                                                )
+                                                        ):
+                                                                needed_games.append(game)
+
+                                                if !needed_games.is_empty():
+                                                        _pending_packages = needed_games
+                                                        var cur_needed = _pending_packages.pop_front()
+                                                        requestDatapackages([cur_needed])
+                                                else:
+                                                        connectToRoom()
+
+                                        elif cmd == "DataPackage":
+                                                for game in message["data"]["games"].keys():
+                                                        _datapackages[game] = message["data"]["games"][game]
+                                                saveDatapackages()
+
+                                                if !_pending_packages.is_empty():
+                                                        var cur_needed = _pending_packages.pop_front()
+                                                        requestDatapackages([cur_needed])
+                                                else:
+                                                        processDatapackages()
+                                                        connectToRoom()
+
+                                        elif cmd == "Connected":
+                                                _authenticated = true
+                                                _team = message["team"]
+                                                _slot = message["slot"]
+                                                _players = message["players"]
+                                                _checked_locations = message["checked_locations"]
+                                                _slot_data = message["slot_data"]
+
+                                                for player in _players:
+                                                        _player_name_by_slot[player["slot"]] = player["alias"]
+                                                        _game_by_player[player["slot"]] = message["slot_info"][str(
+                                                                player["slot"]
+                                                        )]["game"]
+
+                                                emit_signal("client_connected")
+
+                                        elif cmd == "ConnectionRefused":
+                                                var error_message = ""
+                                                for error in message["errors"]:
+                                                        var submsg = ""
+                                                        if error == "InvalidSlot":
+                                                                submsg = "Invalid player name."
+                                                        elif error == "InvalidGame":
+                                                                submsg = "The specified player is not playing Lingo."
+                                                        elif error == "IncompatibleVersion":
+                                                                submsg = (
+                                                                        "The Archipelago server is not the correct version for this client. Expected v%d.%d.%d. Found v%d.%d.%d."
+                                                                        % [
+                                                                                ap_version["major"],
+                                                                                ap_version["minor"],
+                                                                                ap_version["build"],
+                                                                                _remote_version["major"],
+                                                                                _remote_version["minor"],
+                                                                                _remote_version["build"]
+                                                                        ]
+                                                                )
+                                                        elif error == "InvalidPassword":
+                                                                submsg = "Incorrect password."
+                                                        elif error == "InvalidItemsHandling":
+                                                                submsg = "Invalid item handling flag. This is a bug with the client."
+
+                                                        if submsg != "":
+                                                                if error_message != "":
+                                                                        error_message += " "
+                                                                error_message += submsg
+
+                                                if error_message == "":
+                                                        error_message = "Unknown error."
+
+                                                _initiated_disconnect = true
+                                                _ws.disconnect_from_host()
+
+                                                emit_signal("could_not_connect", error_message)
+                                                global._print("Connection to AP refused")
+                                                global._print(message)
+
+                                        elif cmd == "ReceivedItems":
+                                                var i = 0
+                                                for item in message["items"]:
+                                                        if not _received_items.has(int(item["item"])):
+                                                                _received_items.append(int(item["item"]))
+
+                                                        emit_signal(
+                                                                "item_received",
+                                                                int(item["item"]),
+                                                                int(message["index"]) + i,
+                                                                int(item["player"]),
+                                                                int(item["flags"])
+                                                        )
+                                                        i += 1
+
+                                        elif cmd == "PrintJSON":
+                                                emit_signal("message_received", message)
+
+                elif state == WebSocketPeer.STATE_CLOSED:
+                        if _has_connected:
+                                _closed()
+                        else:
+                                _errored()
+
+
+func saveDatapackages():
+        # Save the AP datapackages to disk.
+        var file = FileAccess.open("user://ap_datapackages", FileAccess.WRITE)
+        file.store_var(_datapackages, true)
+        file.close()
+
+
+func connectToServer(server, un, pw):
+        ap_server = server
+        ap_user = un
+        ap_pass = pw
+
+        _initiated_disconnect = false
+
+        var url = ""
+        if ap_server.begins_with("ws://") or ap_server.begins_with("wss://"):
+                url = ap_server
+                _try_wss = false
+        elif _try_wss:
+                url = "wss://" + ap_server
+                _try_wss = false
+        else:
+                url = "ws://" + ap_server
+                _try_wss = true
+
+        var err = _ws.connect_to_url(url)
+        if err != OK:
+                emit_signal(
+                        "could_not_connect",
+                        (
+                                "Could not connect to Archipelago. Check that your server and port are correct. See the error log for more information. Error code: %d."
+                                % err
+                        )
+                )
+                global._print("Could not connect to AP: " + err)
+                return
+        _should_process = true
+
+        emit_signal("connect_status", "Connecting...")
+
+
+func sendMessage(msg):
+        var payload = JSON.stringify(msg)
+        _ws.send_text(payload)
+
+
+func requestDatapackages(games):
+        emit_signal("connect_status", "Downloading %s data package..." % games[0])
+
+        sendMessage([{"cmd": "GetDataPackage", "games": games}])
+
+
+func processDatapackages():
+        _item_id_to_name = {}
+        _location_id_to_name = {}
+        for game in _datapackages.keys():
+                var package = _datapackages[game]
+
+                _item_id_to_name[game] = {}
+                for item_name in package["item_name_to_id"].keys():
+                        _item_id_to_name[game][package["item_name_to_id"][item_name]] = item_name
+
+                _location_id_to_name[game] = {}
+                for location_name in package["location_name_to_id"].keys():
+                        _location_id_to_name[game][package["location_name_to_id"][location_name]] = location_name
+
+        if _datapackages.has("Lingo 2"):
+                _item_name_to_id = _datapackages["Lingo 2"]["item_name_to_id"]
+                _location_name_to_id = _datapackages["Lingo 2"]["location_name_to_id"]
+
+
+func connectToRoom():
+        emit_signal("connect_status", "Authenticating...")
+
+        sendMessage(
+                [
+                        {
+                                "cmd": "Connect",
+                                "password": ap_pass,
+                                "game": "Lingo 2",
+                                "name": ap_user,
+                                "uuid": SCRIPT_uuid.v4(),
+                                "version": ap_version,
+                                "items_handling": 0b111,  # always receive our items
+                                "tags": [],
+                                "slot_data": true
+                        }
+                ]
+        )
+
+
+func sendConnectUpdate(tags):
+        sendMessage([{"cmd": "ConnectUpdate", "tags": tags}])
+
+
+func requestSync():
+        sendMessage([{"cmd": "Sync"}])
+
+
+func sendLocation(loc_id):
+        sendMessage([{"cmd": "LocationChecks", "locations": [loc_id]}])
+
+
+func setValue(key, value, operation = "replace"):
+        sendMessage(
+                [
+                        {
+                                "cmd": "Set",
+                                "key": "Lingo2_%d_%s" % [_slot, key],
+                                "want_reply": false,
+                                "operations": [{"operation": operation, "value": value}]
+                        }
+                ]
+        )
+
+
+func say(textdata):
+        sendMessage([{"cmd": "Say", "text": textdata}])
+
+
+func completedGoal():
+        sendMessage([{"cmd": "StatusUpdate", "status": 30}])  # CLIENT_GOAL
+
+
+func hasItem(item_id):
+        return _received_items.has(item_id)
@@ -0,0 +1,38 @@
+extends "res://scripts/nodes/door.gd"
+
+var item_id
+
+
+func _ready():
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+
+        print("node: %s" % node_path)
+
+        var gamedata = global.get_node("Gamedata")
+        var door_id = gamedata.get_door_for_map_node_path(global.map, node_path)
+        if door_id != null:
+                print("door_id: %d" % door_id)
+
+                var ap = global.get_node("Archipelago")
+                item_id = ap.get_item_id_for_door(door_id)
+
+                if item_id != null:
+                        self.senders = []
+                        self.senderGroup = []
+                        self.nested = false
+                        self.complete_at = 0
+                        self.max_length = 0
+                        self.excludeSenders = []
+
+                        call_deferred("_readier")
+
+        super._ready()
+
+
+func _readier():
+        var ap = global.get_node("Archipelago")
+
+        if ap.has_item(item_id):
+                handleTriggered()
@@ -0,0 +1,78 @@
+extends Node
+
+var SCRIPT_proto
+
+var objects
+var door_id_by_map_node_path = {}
+var painting_id_by_map_node_path = {}
+var door_id_by_ap_id = {}
+var map_id_by_name = {}
+
+
+func _init(proto_script):
+        SCRIPT_proto = proto_script
+
+
+func load(data_bytes):
+        objects = SCRIPT_proto.AllObjects.new()
+
+        var result_code = objects.from_bytes(data_bytes)
+        if result_code != SCRIPT_proto.PB_ERR.NO_ERRORS:
+                print("Could not load generated data: %d" % result_code)
+                return
+
+        for map in objects.get_maps():
+                map_id_by_name[map.get_name()] = map.get_id()
+
+        for door in objects.get_doors():
+                var map = objects.get_maps()[door.get_map_id()]
+
+                if not map.get_name() in door_id_by_map_node_path:
+                        door_id_by_map_node_path[map.get_name()] = {}
+
+                var map_data = door_id_by_map_node_path[map.get_name()]
+                for receiver in door.get_receivers():
+                        map_data[receiver] = door.get_id()
+
+                for painting_id in door.get_move_paintings():
+                        var painting = objects.get_paintings()[painting_id]
+                        map_data[painting.get_path()] = door.get_id()
+
+                if door.has_ap_id():
+                        door_id_by_ap_id[door.get_ap_id()] = door.get_id()
+
+        for painting in objects.get_paintings():
+                var room = objects.get_rooms()[painting.get_room_id()]
+                var map = objects.get_maps()[room.get_map_id()]
+
+                if not map.get_name() in painting_id_by_map_node_path:
+                        painting_id_by_map_node_path[map.get_name()] = {}
+
+                var _map_data = painting_id_by_map_node_path[map.get_name()]
+
+
+func get_door_for_map_node_path(map_name, node_path):
+        if not door_id_by_map_node_path.has(map_name):
+                return null
+
+        var map_data = door_id_by_map_node_path[map_name]
+        return map_data.get(node_path, null)
+
+
+func get_door_ap_id(door_id):
+        var door = objects.get_doors()[door_id]
+        if door.has_ap_id():
+                return door.get_ap_id()
+        else:
+                return null
+
+
+func get_door_receivers(door_id):
+        var door = objects.get_doors()[door_id]
+        return door.get_receivers()
+
+
+func get_door_map_name(door_id):
+        var door = objects.get_doors()[door_id]
+        var map = objects.get_maps()[door.get_map_id()]
+        return map.get_name()
@@ -0,0 +1,20 @@
+extends Receiver
+
+var location_id
+
+
+func _ready():
+        super._ready()
+
+
+func handleTriggered():
+        triggered += 1
+        if triggered >= total:
+                var ap = global.get_node("Archipelago")
+                ap.send_location(location_id)
+
+
+func handleUntriggered():
+        triggered -= 1
+        if triggered < total:
+                pass
@@ -0,0 +1,100 @@
+extends Node
+
+const my_version = "0.1.0"
+
+var SCRIPT_client
+var SCRIPT_locationListener
+var SCRIPT_uuid
+
+var ap_server = ""
+var ap_user = ""
+var ap_pass = ""
+var connection_history = []
+
+var client
+
+signal could_not_connect
+signal connect_status
+signal ap_connected
+
+
+func _ready():
+        client = SCRIPT_client.new()
+        client.SCRIPT_uuid = SCRIPT_uuid
+
+        client.connect("item_received", _process_item)
+        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)
+
+
+func saveSettings():
+        pass
+
+
+func connectToServer():
+        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):
+        var gamedata = global.get_node("Gamedata")
+        var door = gamedata.objects.get_doors()[door_id]
+        if (
+                door.get_type() == gamedata.SCRIPT_proto.DoorType.EVENT
+                or door.get_type() == gamedata.SCRIPT_proto.DoorType.LOCATION_ONLY
+                or door.get_type() == gamedata.SCRIPT_proto.DoorType.CONTROL_CENTER_COLOR
+        ):
+                return null
+        return gamedata.get_door_ap_id(door_id)
+
+
+func has_item(item_id):
+        return client.hasItem(item_id)
+
+
+func _process_item(item_id, _index, _player, _flags):
+        var gamedata = global.get_node("Gamedata")
+        var door_id = gamedata.door_id_by_ap_id.get(item_id, null)
+        if door_id != null and gamedata.get_door_map_name(door_id) == global.map:
+                var receivers = gamedata.get_door_receivers(door_id)
+                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()
+                        for painting_id in gamedata.objects.get_doors()[door_id].get_move_paintings():
+                                var painting = gamedata.objects.get_paintings()[painting_id]
+                                var pnode = scene.get_node_or_null(painting.get_path() + "/teleportListener")
+                                if pnode != null:
+                                        pnode.handleTriggered()
+
+
+func _process_message(_message):
+        pass
+
+
+func _client_could_not_connect():
+        emit_signal("could_not_connect")
+
+
+func _client_connect_status(message):
+        emit_signal("connect_status", message)
+
+
+func _client_connected():
+        emit_signal("ap_connected")
+
+
+func send_location(loc_id):
+        client.sendLocation(loc_id)
@@ -0,0 +1,38 @@
+extends "res://scripts/nodes/painting.gd"
+
+var item_id
+
+
+func _ready():
+        var node_path = String(
+                get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names()
+        )
+
+        print("node: %s" % node_path)
+
+        var gamedata = global.get_node("Gamedata")
+        var door_id = gamedata.get_door_for_map_node_path(global.map, node_path)
+        if door_id != null:
+                print("door_id: %d" % door_id)
+
+                self.senders = []
+                self.senderGroup = []
+                self.nested = false
+                self.complete_at = 0
+                self.max_length = 0
+                self.excludeSenders = []
+
+                var ap = global.get_node("Archipelago")
+                item_id = ap.get_item_id_for_door(door_id)
+
+                if item_id != null:
+                        call_deferred("_readier")
+
+        super._ready()
+
+
+func _readier():
+        var ap = global.get_node("Archipelago")
+
+        if ap.has_item(item_id):
+                $teleportListener.handleTriggered()
@@ -0,0 +1,42 @@
+extends "res://scripts/nodes/player.gd"
+
+
+func _ready():
+        var ap = global.get_node("Archipelago")
+        var gamedata = global.get_node("Gamedata")
+
+        var map_id = gamedata.map_id_by_name.get(global.map)
+        for door in gamedata.objects.get_doors():
+                if door.get_map_id() != map_id:
+                        continue
+
+                if not door.has_ap_id():
+                        continue
+
+                if door.get_type() == gamedata.SCRIPT_proto.DoorType.ITEM_ONLY:
+                        continue
+
+                var locationListener = ap.SCRIPT_locationListener.new()
+                locationListener.location_id = door.get_ap_id()
+                locationListener.name = "locationListener_%d" % door.get_ap_id()
+
+                for panel_ref in door.get_panels():
+                        # TODO: specific answers
+                        var panel_data = gamedata.objects.get_panels()[panel_ref.get_panel()]
+                        locationListener.senders.append(NodePath("/root/scene/" + panel_data.get_path()))
+
+                get_parent().add_child.call_deferred(locationListener)
+
+        for letter in gamedata.objects.get_letters():
+                var room = gamedata.objects.get_rooms()[letter.get_room_id()]
+                if room.get_map_id() != map_id:
+                        continue
+
+                var locationListener = ap.SCRIPT_locationListener.new()
+                locationListener.location_id = letter.get_ap_id()
+                locationListener.name = "locationListener_%d" % letter.get_ap_id()
+                locationListener.senders.append(NodePath("/root/scene/" + letter.get_path()))
+
+                get_parent().add_child.call_deferred(locationListener)
+
+        super._ready()
@@ -0,0 +1,24 @@
+extends Button
+
+
+func _ready():
+        pass
+
+
+func _connect_pressed():
+        self.disabled = true
+
+        var ap = global.get_node("Archipelago")
+        ap.ap_server = self.get_parent().get_node("server_box").text
+        ap.ap_user = self.get_parent().get_node("player_box").text
+        ap.ap_pass = self.get_parent().get_node("password_box").text
+        ap.saveSettings()
+
+        ap.connectToServer()
+
+
+func _back_pressed():
+        var ap = global.get_node("Archipelago")
+        ap.disconnect_from_ap()
+
+        get_tree().change_scene_to_file("res://objects/scenes/menus/main_menu.tscn")
@@ -0,0 +1,173 @@
+extends Node2D
+
+
+func _ready():
+        # Some helpful logging.
+        if Steam.isSubscribed():
+                global._print("Provisioning successful! Build ID: %d" % Steam.getAppBuildId())
+        else:
+                global._print("Provisioning failed.")
+
+        # Undo the load screen removing our cursor
+        get_tree().get_root().set_disable_input(false)
+        Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
+
+        # Increase the WebSocket input buffer size so that we can download large
+        # data packages.
+        ProjectSettings.set_setting("network/limits/websocket_client/max_in_buffer_kb", 8192)
+
+        # Create the global AP manager, if it doesn't already exist.
+        if not global.has_node("Archipelago"):
+                var ap_script = ResourceLoader.load("user://maps/Archipelago/manager.gd")
+                var ap_instance = ap_script.new()
+                ap_instance.name = "Archipelago"
+
+                #apclient_instance.SCRIPT_doorControl = load("user://maps/Archipelago/doorControl.gd")
+                #apclient_instance.SCRIPT_effects = load("user://maps/Archipelago/effects.gd")
+                #apclient_instance.SCRIPT_location = load("user://maps/Archipelago/location.gd")
+                #apclient_instance.SCRIPT_mypainting = load("user://maps/Archipelago/mypainting.gd")
+                #apclient_instance.SCRIPT_panel = load("user://maps/Archipelago/panel.gd")
+                #apclient_instance.SCRIPT_textclient = load("user://maps/Archipelago/textclient.gd")
+
+                ap_instance.SCRIPT_client = load("user://maps/Archipelago/client.gd")
+                ap_instance.SCRIPT_locationListener = load("user://maps/Archipelago/locationListener.gd")
+                ap_instance.SCRIPT_uuid = load("user://maps/Archipelago/vendor/uuid.gd")
+
+                global.add_child(ap_instance)
+
+                # Let's also inject any scripts we need to inject now.
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/door.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/painting.gd"))
+                installScriptExtension(ResourceLoader.load("user://maps/Archipelago/player.gd"))
+
+                var proto_script = load("user://maps/Archipelago/generated/proto.gd")
+                var gamedata_script = load("user://maps/Archipelago/gamedata.gd")
+                var gamedata_instance = gamedata_script.new(proto_script)
+                gamedata_instance.load(
+                        FileAccess.get_file_as_bytes("user://maps/Archipelago/generated/data.binpb")
+                )
+                gamedata_instance.name = "Gamedata"
+                global.add_child(gamedata_instance)
+
+        var ap = global.get_node("Archipelago")
+        ap.connect("ap_connected", connectionSuccessful)
+        ap.connect("could_not_connect", connectionUnsuccessful)
+        ap.connect("connect_status", connectionStatus)
+
+        # Populate textboxes with AP settings.
+        $Panel/server_box.text = ap.ap_server
+        $Panel/player_box.text = ap.ap_user
+        $Panel/password_box.text = ap.ap_pass
+
+        var history_box = $Panel/connection_history
+        if ap.connection_history.is_empty():
+                history_box.disabled = true
+        else:
+                history_box.disabled = false
+
+                var i = 0
+                for details in ap.connection_history:
+                        history_box.get_popup().add_item("%s (%s)" % [details[1], details[0]], i)
+                        i += 1
+
+        history_box.get_popup().connect("id_pressed", historySelected)
+
+        # Show client version.
+        $Panel/title.text = "ARCHIPELAGO (%s)" % ap.my_version
+
+        # Increase font size in text boxes.
+        $Panel/server_box.add_theme_font_size_override("font_size", 36)
+        $Panel/player_box.add_theme_font_size_override("font_size", 36)
+        $Panel/password_box.add_theme_font_size_override("font_size", 36)
+
+
+# Adapted from https://gitlab.com/Delta-V-Modding/Mods/-/blob/main/game/ModLoader.gd
+func installScriptExtension(childScript: Resource):
+        # Force Godot to compile the script now.
+        # We need to do this here to ensure that the inheritance chain is
+        # properly set up, and multiple mods can chain-extend the same
+        # class multiple times.
+        # This is also needed to make Godot instantiate the extended class
+        # when creating singletons.
+        # The actual instance is thrown away.
+        childScript.new()
+
+        var parentScript = childScript.get_base_script()
+        var parentScriptPath = parentScript.resource_path
+        global._print("ModLoader: Installing script extension over %s" % parentScriptPath)
+        childScript.take_over_path(parentScriptPath)
+
+
+func connectionStatus(message):
+        var popup = self.get_node("Panel/AcceptDialog")
+        popup.title = "Connecting to Archipelago"
+        popup.dialog_text = message
+        popup.exclusive = true
+        popup.get_ok_button().visible = false
+        popup.popup_centered()
+
+
+func connectionSuccessful():
+        var ap = global.get_node("Archipelago")
+
+        # Save connection details
+        var connection_details = [ap.ap_server, ap.ap_user, ap.ap_pass]
+        if ap.connection_history.has(connection_details):
+                ap.connection_history.erase(connection_details)
+        ap.connection_history.push_front(connection_details)
+        if ap.connection_history.size() > 10:
+                ap.connection_history.resize(10)
+        ap.saveSettings()
+
+        # Switch to the_entry
+        Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
+        global.user = ap.getSaveFileName()
+        global.universe = "lingo"
+        global.map = "the_entry"
+
+        unlocks.resetKeys()
+        unlocks.resetCollectables()
+        unlocks.resetData()
+        unlocks.loadKeys()
+        unlocks.loadCollectables()
+        unlocks.loadData()
+        unlocks.unlockKey("capslock", 1)
+
+        clearResourceCache("res://objects/nodes/door.tscn")
+        clearResourceCache("res://objects/nodes/player.tscn")
+
+        var paintings_dir = DirAccess.open("res://objects/meshes/paintings")
+        if paintings_dir:
+                paintings_dir.list_dir_begin()
+                var file_name = paintings_dir.get_next()
+                while file_name != "":
+                        if not paintings_dir.current_is_dir() and file_name.ends_with(".tscn"):
+                                clearResourceCache("res://objects/meshes/paintings/" + file_name)
+                        file_name = paintings_dir.get_next()
+
+        switcher.switch_map("res://objects/scenes/the_entry.tscn")
+
+
+func connectionUnsuccessful(error_message):
+        $Panel/connect_button.disabled = false
+
+        var popup = $Panel/AcceptDialog
+        popup.title = "Could not connect to Archipelago"
+        popup.dialog_text = error_message
+        popup.exclusive = true
+        popup.get_ok_button().visible = true
+        popup.popup_centered()
+
+
+func historySelected(index):
+        var ap = global.get_node("Archipelago")
+        var details = ap.connection_history[index]
+
+        $Panel/server_box.text = details[0]
+        $Panel/player_box.text = details[1]
+        $Panel/password_box.text = details[2]
+
+
+func clearResourceCache(path):
+        ResourceLoader.load_threaded_request(path, "", false, ResourceLoader.CACHE_MODE_REPLACE)
+        ResourceLoader.load_threaded_get(path)
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Xavier Sellier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
@@ -0,0 +1,195 @@
+# Note: The code might not be as pretty it could be, since it's written
+# in a way that maximizes performance. Methods are inlined and loops are avoided.
+extends Node
+
+const BYTE_MASK: int = 0b11111111
+
+
+static func uuidbin():
+        randomize()
+        # 16 random bytes with the bytes on index 6 and 8 modified
+        return [
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+                ((randi() & BYTE_MASK) & 0x0f) | 0x40,
+                randi() & BYTE_MASK,
+                ((randi() & BYTE_MASK) & 0x3f) | 0x80,
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+                randi() & BYTE_MASK,
+        ]
+
+
+static func uuidbinrng(rng: RandomNumberGenerator):
+        rng.randomize()
+        return [
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+                ((rng.randi() & BYTE_MASK) & 0x0f) | 0x40,
+                rng.randi() & BYTE_MASK,
+                ((rng.randi() & BYTE_MASK) & 0x3f) | 0x80,
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+                rng.randi() & BYTE_MASK,
+        ]
+
+
+static func v4():
+        # 16 random bytes with the bytes on index 6 and 8 modified
+        var b = uuidbin()
+
+        return (
+                "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x"
+                % [
+                        # low
+                        b[0],
+                        b[1],
+                        b[2],
+                        b[3],
+                        # mid
+                        b[4],
+                        b[5],
+                        # hi
+                        b[6],
+                        b[7],
+                        # clock
+                        b[8],
+                        b[9],
+                        # clock
+                        b[10],
+                        b[11],
+                        b[12],
+                        b[13],
+                        b[14],
+                        b[15]
+                ]
+        )
+
+
+static func v4_rng(rng: RandomNumberGenerator):
+        # 16 random bytes with the bytes on index 6 and 8 modified
+        var b = uuidbinrng(rng)
+
+        return (
+                "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x"
+                % [
+                        # low
+                        b[0],
+                        b[1],
+                        b[2],
+                        b[3],
+                        # mid
+                        b[4],
+                        b[5],
+                        # hi
+                        b[6],
+                        b[7],
+                        # clock
+                        b[8],
+                        b[9],
+                        # clock
+                        b[10],
+                        b[11],
+                        b[12],
+                        b[13],
+                        b[14],
+                        b[15]
+                ]
+        )
+
+
+var _uuid: Array
+
+
+func _init(rng := RandomNumberGenerator.new()) -> void:
+        _uuid = uuidbinrng(rng)
+
+
+func as_array() -> Array:
+        return _uuid.duplicate()
+
+
+func as_dict(big_endian := true) -> Dictionary:
+        if big_endian:
+                return {
+                        "low": (_uuid[0] << 24) + (_uuid[1] << 16) + (_uuid[2] << 8) + _uuid[3],
+                        "mid": (_uuid[4] << 8) + _uuid[5],
+                        "hi": (_uuid[6] << 8) + _uuid[7],
+                        "clock": (_uuid[8] << 8) + _uuid[9],
+                        "node":
+                        (
+                                (_uuid[10] << 40)
+                                + (_uuid[11] << 32)
+                                + (_uuid[12] << 24)
+                                + (_uuid[13] << 16)
+                                + (_uuid[14] << 8)
+                                + _uuid[15]
+                        )
+                }
+        else:
+                return {
+                        "low": _uuid[0] + (_uuid[1] << 8) + (_uuid[2] << 16) + (_uuid[3] << 24),
+                        "mid": _uuid[4] + (_uuid[5] << 8),
+                        "hi": _uuid[6] + (_uuid[7] << 8),
+                        "clock": _uuid[8] + (_uuid[9] << 8),
+                        "node":
+                        (
+                                _uuid[10]
+                                + (_uuid[11] << 8)
+                                + (_uuid[12] << 16)
+                                + (_uuid[13] << 24)
+                                + (_uuid[14] << 32)
+                                + (_uuid[15] << 40)
+                        )
+                }
+
+
+func as_string() -> String:
+        return (
+                "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x"
+                % [
+                        # low
+                        _uuid[0],
+                        _uuid[1],
+                        _uuid[2],
+                        _uuid[3],
+                        # mid
+                        _uuid[4],
+                        _uuid[5],
+                        # hi
+                        _uuid[6],
+                        _uuid[7],
+                        # clock
+                        _uuid[8],
+                        _uuid[9],
+                        # node
+                        _uuid[10],
+                        _uuid[11],
+                        _uuid[12],
+                        _uuid[13],
+                        _uuid[14],
+                        _uuid[15]
+                ]
+        )
+
+
+func is_equal(other) -> bool:
+        # Godot Engine compares Array recursively
+        # There's no need for custom comparison here.
+        return _uuid == other._uuid