1 files changed, 77 insertions, 124 deletions

@@ -6,8 +6,8 @@ var SCRIPT_client
 var SCRIPT_keyboard
 var SCRIPT_locationListener
 var SCRIPT_minimap
-var SCRIPT_uuid
 var SCRIPT_victoryListener
+var SCRIPT_websocketserver
 
 var ap_server = ""
 var ap_user = ""
@@ -92,14 +92,17 @@ func _init():
 
 func _ready():
         client = SCRIPT_client.new()
-        client.SCRIPT_uuid = SCRIPT_uuid
+        client.SCRIPT_websocketserver = SCRIPT_websocketserver
 
-        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)
+        client.item_received.connect(_process_item)
+        client.location_scout_received.connect(_process_location_scout)
+        client.text_message_received.connect(_process_text_message)
+        client.item_sent_notification.connect(_process_item_sent_notification)
+        client.hint_received.connect(_process_hint_received)
+
+        client.could_not_connect.connect(_client_could_not_connect)
+        client.connect_status.connect(_client_connect_status)
+        client.client_connected.connect(_client_connected)
 
         add_child(client)
 
@@ -163,20 +166,17 @@ 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]
-
+func _process_item(item, amount):
         var gamedata = global.get_node("Gamedata")
 
+        var item_id = int(item["id"])
         var prog_id = null
-        if _inverse_item_locks.has(item):
-                for lock in _inverse_item_locks.get(item):
+        if _inverse_item_locks.has(item_id):
+                for lock in _inverse_item_locks.get(item_id):
                         if lock[1] != amount:
                                 continue
 
-                        if gamedata.progressive_id_by_ap_id.has(item):
+                        if gamedata.progressive_id_by_ap_id.has(item_id):
                                 prog_id = lock[0]
 
                         if gamedata.get_door_map_name(lock[0]) != global.map:
@@ -190,38 +190,35 @@ func _process_item(item, index, from, flags, amount):
                                         if rnode != null:
                                                 rnode.handleTriggered()
 
-        var letter_id = gamedata.letter_id_by_ap_id.get(item, null)
+        var letter_id = gamedata.letter_id_by_ap_id.get(item_id, 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):
+        if gamedata.symbol_item_ids.has(item_id):
                 var player = get_tree().get_root().get_node_or_null("scene/player")
                 if player != null:
-                        player.emit_signal("evaluate_solvability")
+                        player.evaluate_solvability.emit()
 
         # Show a message about the item if it's new.
-        if index != null and index > _last_new_item:
-                _last_new_item = index
+        if int(item["index"]) > _last_new_item:
+                _last_new_item = int(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 full_item_name = item_name
+                var full_item_name = item["text"]
                 if prog_id != null:
                         var door = gamedata.objects.get_doors()[prog_id]
-                        full_item_name = "%s (%s)" % [item_name, door.get_name()]
+                        full_item_name = "%s (%s)" % [full_item_name, door.get_name()]
 
                 var message
-                if from == client._slot:
-                        message = "Found %s" % wrapInItemColorTags(full_item_name, flags)
-                else:
+                if "sender" in item:
                         message = (
-                                "Received %s from %s" % [wrapInItemColorTags(full_item_name, flags), player_name]
+                                "Received %s from %s"
+                                % [wrapInItemColorTags(full_item_name, item["flags"]), item["sender"]]
                         )
+                else:
+                        message = "Found %s" % wrapInItemColorTags(full_item_name, item["flags"])
 
                 if gamedata.anti_trap_ids.has(item):
                         keyboard.block_letter(gamedata.anti_trap_ids[item])
@@ -231,112 +228,68 @@ func _process_item(item, index, from, flags, amount):
                 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: %s%s is on %s"
-                                        % [
-                                                wrapInItemColorTags(item_name, message["item"]["flags"]),
-                                                is_for,
-                                                location_name
-                                        ]
-                                )
-                        )
-        else:
-                if message["receiving"] != client._slot:
-                        var sentMsg = (
-                                "Sent %s to %s"
-                                % [wrapInItemColorTags(item_name, message["item"]["flags"]), 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):
+func _process_item_sent_notification(message):
+        var sentMsg = (
+                "Sent %s to %s"
+                % [
+                        wrapInItemColorTags(message["item_name"], message["item_flags"]),
+                        message["receiver_name"]
+                ]
+        )
+        #if _hinted_locations.has(message["item"]["location"]):
+        #       sentMsg += " ([color=#fafad2]Hinted![/color])"
+        global.get_node("Messages").showMessage(sentMsg)
+
+
+func _process_hint_received(message):
+        var is_for = ""
+        if message["self"] == 0:
+                is_for = " for %s" % message["receiver_name"]
+
+        global.get_node("Messages").showMessage(
+                (
+                        "Hint: %s%s is on %s"
+                        % [
+                                wrapInItemColorTags(message["item_name"], message["item_flags"]),
+                                is_for,
+                                message["location_name"]
+                        ]
+                )
+        )
+
+
+func _process_text_message(message):
         var parts = []
-        for message_part in message["data"]:
-                if !message_part.has("type") and message_part.has("text"):
+        for message_part in message:
+                if message_part["type"] == "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]
-                                )
+                elif message_part["type"] == "player":
+                        if message_part["self"] == 1:
+                                parts.append("[color=#ee00ee]%s[/color]" % message_part["text"])
                         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(wrapInItemColorTags(item_name, message_part["flags"]))
-                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"])
+                                parts.append("[color=#fafad2]%s[/color]" % message_part["text"])
+                elif message_part["type"] == "item":
+                        parts.append(wrapInItemColorTags(message_part["text"], message_part["flags"]))
+                elif message_part["type"] == "location":
+                        parts.append("[color=#00ff7f]%s[/color]" % 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}
+func _process_location_scout(location_id, item_name, player_name, flags, for_self):
+        _location_scouts[location_id] = {
+                "item": item_name, "player": player_name, "flags": flags, "for_self": for_self
+        }
 
-        if player == client._slot and flags & 4 != 0:
+        if for_self 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]
@@ -350,11 +303,11 @@ func _process_location_scout(item_id, location_id, player, flags):
 
 
 func _client_could_not_connect(message):
-        emit_signal("could_not_connect", message)
+        could_not_connect.emit(message)
 
 
 func _client_connect_status(message):
-        emit_signal("connect_status", message)
+        connect_status.emit(message)
 
 
 func _client_connected(slot_data):
@@ -463,7 +416,7 @@ func _client_connected(slot_data):
 
                 _inverse_item_locks[lock[0]].append([door_id, lock[1]])
 
-        emit_signal("ap_connected")
+        ap_connected.emit()
 
 
 func start_batching_locations():