1 files changed, 100 insertions, 21 deletions

@@ -1,6 +1,6 @@
 extends Node
 
-const my_version = "0.1.0"
+const MOD_VERSION = 6
 
 var SCRIPT_client
 var SCRIPT_keyboard
@@ -23,6 +23,7 @@ var _held_locations = []
 var _held_location_scouts = []
 var _location_scouts = {}
 var _item_locks = {}
+var _inverse_item_locks = {}
 var _held_letters = {}
 var _letters_setup = false
 
@@ -36,10 +37,19 @@ 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
@@ -121,6 +131,10 @@ func saveLocaldata():
 
 func connectToServer():
         _last_new_item = -1
+        _batch_locations = false
+        _held_locations = []
+        _held_location_scouts = []
+        _location_scouts = {}
         _letters_setup = false
         _held_letters = {}
 
@@ -145,24 +159,26 @@ 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 _inverse_item_locks.has(item):
+                for lock in _inverse_item_locks.get(item):
+                        if lock[1] != amount:
+                                continue
 
-        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()
+                        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:
@@ -170,6 +186,11 @@ func _process_item(item, index, from, flags, amount):
                 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
@@ -182,8 +203,8 @@ func _process_item(item, index, from, flags, amount):
                 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
@@ -194,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)
@@ -288,6 +312,10 @@ func parse_printjson_for_textclient(message):
 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)
 
@@ -308,8 +336,8 @@ func _process_location_scout(item_id, location_id, player, flags):
                                 collectable.setScoutedText(item_name)
 
 
-func _client_could_not_connect():
-        emit_signal("could_not_connect")
+func _client_could_not_connect(message):
+        emit_signal("could_not_connect", message)
 
 
 func _client_connect_status(message):
@@ -337,12 +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 = {}
 
@@ -359,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")
 
 
@@ -453,4 +529,7 @@ func _process_key_item(key, level):
                 _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)