1 files changed, 229 insertions, 38 deletions

@@ -1,8 +1,9 @@
 extends Node
 
-const my_version = "0.1.0"
+const MOD_VERSION = 4
 
 var SCRIPT_client
+var SCRIPT_keyboard
 var SCRIPT_locationListener
 var SCRIPT_uuid
 var SCRIPT_victoryListener
@@ -13,15 +14,42 @@ 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 apworld_version = [0, 0]
+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_gallery_paintings = false
+var shuffle_letters = kSHUFFLE_LETTERS_VANILLA
+var shuffle_symbols = false
 var victory_condition = -1
 
 signal could_not_connect
@@ -59,12 +87,16 @@ func _ready():
 
         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.
@@ -99,6 +131,12 @@ func saveLocaldata():
 
 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)
 
@@ -121,29 +159,37 @@ func _process_item(item, index, from, flags, amount):
                 item_name = client._item_id_to_name["Lingo 2"][item]
 
         var gamedata = global.get_node("Gamedata")
-        var door_id = gamedata.door_id_by_ap_id.get(item, null)
-        var prog_id = null
 
-        if door_id == null:
-                prog_id = gamedata.progressive_id_by_ap_id.get(item, null)
-                if prog_id != null:
-                        var progressive = gamedata.objects.get_progressives()[prog_id]
-                        if progressive.get_doors().size() >= amount:
-                                door_id = progressive.get_doors()[amount - 1]
-
-        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()
+        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:
@@ -151,14 +197,14 @@ func _process_item(item, index, from, flags, amount):
                 saveLocaldata()
 
                 var player_name = "Unknown"
-                if client._player_name_by_slot.has(from):
-                        player_name = client._player_name_by_slot[from]
+                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 and door_id != null:
-                        var door = gamedata.objects.get_doors()[door_id]
+                if prog_id != null:
+                        var door = gamedata.objects.get_doors()[prog_id]
                         full_item_name = "%s (%s)" % [item_name, door.get_name()]
 
                 var message
@@ -169,6 +215,9 @@ func _process_item(item, index, from, flags, amount):
                                 "Received [color=%s]%s[/color] from %s" % [item_color, full_item_name, player_name]
                         )
 
+                if gamedata.anti_trap_ids.has(item):
+                        keyboard.block_letter(gamedata.anti_trap_ids[item])
+
                 global._print(message)
 
                 global.get_node("Messages").showMessage(message)
@@ -186,15 +235,15 @@ func _process_message(message):
 
         var item_name = "Unknown"
         var item_player_game = client._game_by_player[message["receiving"]]
-        if client._item_id_to_name[item_player_game].has(message["item"]["item"]):
-                item_name = client._item_id_to_name[item_player_game][message["item"]["item"]]
+        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(message["item"]["location"]):
-                location_name = (
-                        client._location_id_to_name[location_player_game][message["item"]["location"]]
-                )
+        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"]):
@@ -260,8 +309,35 @@ func parse_printjson_for_textclient(message):
                 textclient_node.parse_printjson("".join(parts))
 
 
-func _client_could_not_connect():
-        emit_signal("could_not_connect")
+func _process_location_scout(item_id, location_id, player, flags):
+        _location_scouts[location_id] = {"item": item_id, "player": player, "flags": flags}
+
+        if player == client._slot and flags & 4 != 0:
+                # This is a trap for us, so let's not display it.
+                return
+
+        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(message):
+        emit_signal("could_not_connect", message)
 
 
 func _client_connect_status(message):
@@ -289,10 +365,19 @@ func _client_connected(slot_data):
                         _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_gallery_paintings = bool(slot_data.get("shuffle_gallery_paintings", 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))
 
+        if slot_data.has("version"):
+                apworld_version = [int(slot_data["version"][0]), int(slot_data["version"][1])]
+
         # Set up item locks.
         _item_locks = {}
 
@@ -309,6 +394,47 @@ func _client_connected(slot_data):
                                 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 shuffle_gallery_paintings:
+                for door in gamedata.objects.get_doors():
+                        if door.get_type() == gamedata.SCRIPT_proto.DoorType.GALLERY_PAINTING:
+                                _item_locks[door.get_id()] = [door.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")
 
 
@@ -323,10 +449,28 @@ func send_location(loc_id):
                 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
-        client.sendLocations(_held_locations)
-        _held_locations.clear()
+
+        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):
@@ -342,3 +486,50 @@ func colorForItemType(flags):
                 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
+
+        if shuffle_letters == kSHUFFLE_LETTERS_ITEM_CYAN:
+                level += 1
+
+        keyboard.collect_remote_letter(key, level)