diff options
| author | Star Rauchenberger <fefferburbia@gmail.com> | 2025-09-25 12:09:50 -0400 |
|---|---|---|
| committer | Star Rauchenberger <fefferburbia@gmail.com> | 2025-09-25 12:09:50 -0400 |
| commit | 3f53502a5907ed1982d28a392c54331f0c1c2c42 (patch) | |
| tree | 1dd087464d0fba1c35feaab0cee357fca6f2763c /client | |
| parent | fb220e1c75e72a536c19aa1283f905850a91cf44 (diff) | |
| download | lingo2-archipelago-3f53502a5907ed1982d28a392c54331f0c1c2c42.tar.gz lingo2-archipelago-3f53502a5907ed1982d28a392c54331f0c1c2c42.tar.bz2 lingo2-archipelago-3f53502a5907ed1982d28a392c54331f0c1c2c42.zip | |
Move the client into the apworld
Only works on source right now, not as an apworld.
Diffstat (limited to 'client')
32 files changed, 0 insertions, 3255 deletions
| diff --git a/client/Archipelago/animationListener.gd b/client/Archipelago/animationListener.gd deleted file mode 100644 index c3b26db..0000000 --- a/client/Archipelago/animationListener.gd +++ /dev/null | |||
| @@ -1,38 +0,0 @@ | |||
| 1 | extends "res://scripts/nodes/listeners/animationListener.gd" | ||
| 2 | |||
| 3 | var item_id | ||
| 4 | var item_amount | ||
| 5 | |||
| 6 | |||
| 7 | func _ready(): | ||
| 8 | var node_path = String( | ||
| 9 | get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names() | ||
| 10 | ) | ||
| 11 | |||
| 12 | var gamedata = global.get_node("Gamedata") | ||
| 13 | var door_id = gamedata.get_door_for_map_node_path(global.map, node_path) | ||
| 14 | if door_id != null: | ||
| 15 | var ap = global.get_node("Archipelago") | ||
| 16 | var item_lock = ap.get_item_id_for_door(door_id) | ||
| 17 | |||
| 18 | if item_lock != null: | ||
| 19 | item_id = item_lock[0] | ||
| 20 | item_amount = item_lock[1] | ||
| 21 | |||
| 22 | self.senders = [] | ||
| 23 | self.senderGroup = [] | ||
| 24 | self.nested = false | ||
| 25 | self.complete_at = 0 | ||
| 26 | self.max_length = 0 | ||
| 27 | self.excludeSenders = [] | ||
| 28 | |||
| 29 | call_deferred("_readier") | ||
| 30 | |||
| 31 | super._ready() | ||
| 32 | |||
| 33 | |||
| 34 | func _readier(): | ||
| 35 | var ap = global.get_node("Archipelago") | ||
| 36 | |||
| 37 | if ap.client.getItemAmount(item_id) >= item_amount: | ||
| 38 | handleTriggered() | ||
| diff --git a/client/Archipelago/client.gd b/client/Archipelago/client.gd deleted file mode 100644 index 843647d..0000000 --- a/client/Archipelago/client.gd +++ /dev/null | |||
| @@ -1,417 +0,0 @@ | |||
| 1 | extends Node | ||
| 2 | |||
| 3 | const ap_version = {"major": 0, "minor": 6, "build": 3, "class": "Version"} | ||
| 4 | |||
| 5 | var SCRIPT_uuid | ||
| 6 | |||
| 7 | var _ws = WebSocketPeer.new() | ||
| 8 | var _should_process = false | ||
| 9 | var _initiated_disconnect = false | ||
| 10 | var _try_wss = false | ||
| 11 | var _has_connected = false | ||
| 12 | |||
| 13 | var _datapackages = {} | ||
| 14 | var _pending_packages = [] | ||
| 15 | var _item_id_to_name = {} # All games | ||
| 16 | var _location_id_to_name = {} # All games | ||
| 17 | var _item_name_to_id = {} # Lingo 2 only | ||
| 18 | var _location_name_to_id = {} # Lingo 2 only | ||
| 19 | |||
| 20 | var _remote_version = {"major": 0, "minor": 0, "build": 0} | ||
| 21 | var _gen_version = {"major": 0, "minor": 0, "build": 0} | ||
| 22 | |||
| 23 | var ap_server = "" | ||
| 24 | var ap_user = "" | ||
| 25 | var ap_pass = "" | ||
| 26 | |||
| 27 | var _authenticated = false | ||
| 28 | var _seed = "" | ||
| 29 | var _team = 0 | ||
| 30 | var _slot = 0 | ||
| 31 | var _players = [] | ||
| 32 | var _player_name_by_slot = {} | ||
| 33 | var _game_by_player = {} | ||
| 34 | var _checked_locations = [] | ||
| 35 | var _received_indexes = [] | ||
| 36 | var _received_items = {} | ||
| 37 | var _slot_data = {} | ||
| 38 | |||
| 39 | signal could_not_connect | ||
| 40 | signal connect_status | ||
| 41 | signal client_connected(slot_data) | ||
| 42 | signal item_received(item_id, index, player, flags, amount) | ||
| 43 | signal message_received(message) | ||
| 44 | signal location_scout_received(item_id, location_id, player, flags) | ||
| 45 | |||
| 46 | |||
| 47 | func _init(): | ||
| 48 | set_process_mode(Node.PROCESS_MODE_ALWAYS) | ||
| 49 | |||
| 50 | _ws.inbound_buffer_size = 8388608 | ||
| 51 | |||
| 52 | global._print("Instantiated APClient") | ||
| 53 | |||
| 54 | # Read AP datapackages from file, if there are any | ||
| 55 | if FileAccess.file_exists("user://ap_datapackages"): | ||
| 56 | var file = FileAccess.open("user://ap_datapackages", FileAccess.READ) | ||
| 57 | var data = file.get_var(true) | ||
| 58 | file.close() | ||
| 59 | |||
| 60 | if typeof(data) != TYPE_DICTIONARY: | ||
| 61 | global._print("AP datapackages file is corrupted") | ||
| 62 | data = {} | ||
| 63 | |||
| 64 | _datapackages = data | ||
| 65 | |||
| 66 | processDatapackages() | ||
| 67 | |||
| 68 | |||
| 69 | func _ready(): | ||
| 70 | pass | ||
| 71 | #_ws.connect("connection_closed", _closed) | ||
| 72 | #_ws.connect("connection_failed", _closed) | ||
| 73 | #_ws.connect("server_disconnected", _closed) | ||
| 74 | #_ws.connect("connection_error", _errored) | ||
| 75 | #_ws.connect("connection_established", _connected) | ||
| 76 | |||
| 77 | |||
| 78 | func _reset_state(): | ||
| 79 | _should_process = false | ||
| 80 | _authenticated = false | ||
| 81 | _try_wss = false | ||
| 82 | _has_connected = false | ||
| 83 | _received_items = {} | ||
| 84 | _received_indexes = [] | ||
| 85 | |||
| 86 | |||
| 87 | func _errored(): | ||
| 88 | if _try_wss: | ||
| 89 | global._print("Could not connect to AP with ws://, now trying wss://") | ||
| 90 | connectToServer(ap_server, ap_user, ap_pass) | ||
| 91 | else: | ||
| 92 | global._print("AP connection failed") | ||
| 93 | _reset_state() | ||
| 94 | |||
| 95 | emit_signal( | ||
| 96 | "could_not_connect", | ||
| 97 | "Could not connect to Archipelago. Check that your server and port are correct. See the error log for more information." | ||
| 98 | ) | ||
| 99 | |||
| 100 | |||
| 101 | func _closed(_was_clean = true): | ||
| 102 | global._print("Connection closed") | ||
| 103 | _reset_state() | ||
| 104 | |||
| 105 | if not _initiated_disconnect: | ||
| 106 | emit_signal("could_not_connect", "Disconnected from Archipelago") | ||
| 107 | |||
| 108 | _initiated_disconnect = false | ||
| 109 | |||
| 110 | |||
| 111 | func _connected(_proto = ""): | ||
| 112 | global._print("Connected!") | ||
| 113 | _try_wss = false | ||
| 114 | |||
| 115 | |||
| 116 | func disconnect_from_ap(): | ||
| 117 | _initiated_disconnect = true | ||
| 118 | _ws.close() | ||
| 119 | |||
| 120 | |||
| 121 | func _process(_delta): | ||
| 122 | if _should_process: | ||
| 123 | _ws.poll() | ||
| 124 | |||
| 125 | var state = _ws.get_ready_state() | ||
| 126 | if state == WebSocketPeer.STATE_OPEN: | ||
| 127 | if not _has_connected: | ||
| 128 | _has_connected = true | ||
| 129 | |||
| 130 | _connected() | ||
| 131 | |||
| 132 | while _ws.get_available_packet_count(): | ||
| 133 | var packet = _ws.get_packet() | ||
| 134 | global._print("Got data from server: " + packet.get_string_from_utf8()) | ||
| 135 | var json = JSON.new() | ||
| 136 | var jserror = json.parse(packet.get_string_from_utf8()) | ||
| 137 | if jserror != OK: | ||
| 138 | global._print("Error parsing packet from AP: " + jserror.error_string) | ||
| 139 | return | ||
| 140 | |||
| 141 | for message in json.data: | ||
| 142 | var cmd = message["cmd"] | ||
| 143 | global._print("Received command: " + cmd) | ||
| 144 | |||
| 145 | if cmd == "RoomInfo": | ||
| 146 | _seed = message["seed_name"] | ||
| 147 | _remote_version = message["version"] | ||
| 148 | _gen_version = message["generator_version"] | ||
| 149 | |||
| 150 | var needed_games = [] | ||
| 151 | for game in message["datapackage_checksums"].keys(): | ||
| 152 | if ( | ||
| 153 | !_datapackages.has(game) | ||
| 154 | or ( | ||
| 155 | _datapackages[game]["checksum"] | ||
| 156 | != message["datapackage_checksums"][game] | ||
| 157 | ) | ||
| 158 | ): | ||
| 159 | needed_games.append(game) | ||
| 160 | |||
| 161 | if !needed_games.is_empty(): | ||
| 162 | _pending_packages = needed_games | ||
| 163 | var cur_needed = _pending_packages.pop_front() | ||
| 164 | requestDatapackages([cur_needed]) | ||
| 165 | else: | ||
| 166 | connectToRoom() | ||
| 167 | |||
| 168 | elif cmd == "DataPackage": | ||
| 169 | for game in message["data"]["games"].keys(): | ||
| 170 | _datapackages[game] = message["data"]["games"][game] | ||
| 171 | saveDatapackages() | ||
| 172 | |||
| 173 | if !_pending_packages.is_empty(): | ||
| 174 | var cur_needed = _pending_packages.pop_front() | ||
| 175 | requestDatapackages([cur_needed]) | ||
| 176 | else: | ||
| 177 | processDatapackages() | ||
| 178 | connectToRoom() | ||
| 179 | |||
| 180 | elif cmd == "Connected": | ||
| 181 | _authenticated = true | ||
| 182 | _team = message["team"] | ||
| 183 | _slot = message["slot"] | ||
| 184 | _players = message["players"] | ||
| 185 | _checked_locations = message["checked_locations"] | ||
| 186 | _slot_data = message["slot_data"] | ||
| 187 | |||
| 188 | for player in _players: | ||
| 189 | _player_name_by_slot[player["slot"]] = player["alias"] | ||
| 190 | _game_by_player[player["slot"]] = message["slot_info"][str( | ||
| 191 | player["slot"] | ||
| 192 | )]["game"] | ||
| 193 | |||
| 194 | emit_signal("client_connected", _slot_data) | ||
| 195 | |||
| 196 | elif cmd == "ConnectionRefused": | ||
| 197 | var error_message = "" | ||
| 198 | for error in message["errors"]: | ||
| 199 | var submsg = "" | ||
| 200 | if error == "InvalidSlot": | ||
| 201 | submsg = "Invalid player name." | ||
| 202 | elif error == "InvalidGame": | ||
| 203 | submsg = "The specified player is not playing Lingo." | ||
| 204 | elif error == "IncompatibleVersion": | ||
| 205 | submsg = ( | ||
| 206 | "The Archipelago server is not the correct version for this client. Expected v%d.%d.%d. Found v%d.%d.%d." | ||
| 207 | % [ | ||
| 208 | ap_version["major"], | ||
| 209 | ap_version["minor"], | ||
| 210 | ap_version["build"], | ||
| 211 | _remote_version["major"], | ||
| 212 | _remote_version["minor"], | ||
| 213 | _remote_version["build"] | ||
| 214 | ] | ||
| 215 | ) | ||
| 216 | elif error == "InvalidPassword": | ||
| 217 | submsg = "Incorrect password." | ||
| 218 | elif error == "InvalidItemsHandling": | ||
| 219 | submsg = "Invalid item handling flag. This is a bug with the client." | ||
| 220 | |||
| 221 | if submsg != "": | ||
| 222 | if error_message != "": | ||
| 223 | error_message += " " | ||
| 224 | error_message += submsg | ||
| 225 | |||
| 226 | if error_message == "": | ||
| 227 | error_message = "Unknown error." | ||
| 228 | |||
| 229 | _initiated_disconnect = true | ||
| 230 | _ws.close() | ||
| 231 | |||
| 232 | emit_signal("could_not_connect", error_message) | ||
| 233 | global._print("Connection to AP refused") | ||
| 234 | global._print(message) | ||
| 235 | |||
| 236 | elif cmd == "ReceivedItems": | ||
| 237 | var i = 0 | ||
| 238 | for item in message["items"]: | ||
| 239 | var index = int(message["index"] + i) | ||
| 240 | i += 1 | ||
| 241 | |||
| 242 | if _received_indexes.has(index): | ||
| 243 | # Do not re-process items. | ||
| 244 | continue | ||
| 245 | |||
| 246 | _received_indexes.append(index) | ||
| 247 | |||
| 248 | var item_id = int(item["item"]) | ||
| 249 | _received_items[item_id] = _received_items.get(item_id, 0) + 1 | ||
| 250 | |||
| 251 | emit_signal( | ||
| 252 | "item_received", | ||
| 253 | item_id, | ||
| 254 | index, | ||
| 255 | int(item["player"]), | ||
| 256 | int(item["flags"]), | ||
| 257 | _received_items[item_id] | ||
| 258 | ) | ||
| 259 | |||
| 260 | elif cmd == "PrintJSON": | ||
| 261 | emit_signal("message_received", message) | ||
| 262 | |||
| 263 | elif cmd == "LocationInfo": | ||
| 264 | for loc in message["locations"]: | ||
| 265 | emit_signal( | ||
| 266 | "location_scout_received", | ||
| 267 | int(loc["item"]), | ||
| 268 | int(loc["location"]), | ||
| 269 | int(loc["player"]), | ||
| 270 | int(loc["flags"]) | ||
| 271 | ) | ||
| 272 | |||
| 273 | elif state == WebSocketPeer.STATE_CLOSED: | ||
| 274 | if _has_connected: | ||
| 275 | _closed() | ||
| 276 | else: | ||
| 277 | _errored() | ||
| 278 | |||
| 279 | |||
| 280 | func saveDatapackages(): | ||
| 281 | # Save the AP datapackages to disk. | ||
| 282 | var file = FileAccess.open("user://ap_datapackages", FileAccess.WRITE) | ||
| 283 | file.store_var(_datapackages, true) | ||
| 284 | file.close() | ||
| 285 | |||
| 286 | |||
| 287 | func connectToServer(server, un, pw): | ||
| 288 | ap_server = server | ||
| 289 | ap_user = un | ||
| 290 | ap_pass = pw | ||
| 291 | |||
| 292 | _initiated_disconnect = false | ||
| 293 | |||
| 294 | var url = "" | ||
| 295 | if ap_server.begins_with("ws://") or ap_server.begins_with("wss://"): | ||
| 296 | url = ap_server | ||
| 297 | _try_wss = false | ||
| 298 | elif _try_wss: | ||
| 299 | url = "wss://" + ap_server | ||
| 300 | _try_wss = false | ||
| 301 | else: | ||
| 302 | url = "ws://" + ap_server | ||
| 303 | _try_wss = true | ||
| 304 | |||
| 305 | var err = _ws.connect_to_url(url) | ||
| 306 | if err != OK: | ||
| 307 | emit_signal( | ||
| 308 | "could_not_connect", | ||
| 309 | ( | ||
| 310 | "Could not connect to Archipelago. Check that your server and port are correct. See the error log for more information. Error code: %d." | ||
| 311 | % err | ||
| 312 | ) | ||
| 313 | ) | ||
| 314 | global._print("Could not connect to AP: %d" % err) | ||
| 315 | return | ||
| 316 | _should_process = true | ||
| 317 | |||
| 318 | emit_signal("connect_status", "Connecting...") | ||
| 319 | |||
| 320 | |||
| 321 | func sendMessage(msg): | ||
| 322 | var payload = JSON.stringify(msg) | ||
| 323 | _ws.send_text(payload) | ||
| 324 | |||
| 325 | |||
| 326 | func requestDatapackages(games): | ||
| 327 | emit_signal("connect_status", "Downloading %s data package..." % games[0]) | ||
| 328 | |||
| 329 | sendMessage([{"cmd": "GetDataPackage", "games": games}]) | ||
| 330 | |||
| 331 | |||
| 332 | func processDatapackages(): | ||
| 333 | _item_id_to_name = {} | ||
| 334 | _location_id_to_name = {} | ||
| 335 | for game in _datapackages.keys(): | ||
| 336 | var package = _datapackages[game] | ||
| 337 | |||
| 338 | _item_id_to_name[game] = {} | ||
| 339 | for item_name in package["item_name_to_id"].keys(): | ||
| 340 | _item_id_to_name[game][int(package["item_name_to_id"][item_name])] = item_name | ||
| 341 | |||
| 342 | _location_id_to_name[game] = {} | ||
| 343 | for location_name in package["location_name_to_id"].keys(): | ||
| 344 | _location_id_to_name[game][int(package["location_name_to_id"][location_name])] = location_name | ||
| 345 | |||
| 346 | if _datapackages.has("Lingo 2"): | ||
| 347 | _item_name_to_id = _datapackages["Lingo 2"]["item_name_to_id"] | ||
| 348 | _location_name_to_id = _datapackages["Lingo 2"]["location_name_to_id"] | ||
| 349 | |||
| 350 | |||
| 351 | func connectToRoom(): | ||
| 352 | emit_signal("connect_status", "Authenticating...") | ||
| 353 | |||
| 354 | sendMessage( | ||
| 355 | [ | ||
| 356 | { | ||
| 357 | "cmd": "Connect", | ||
| 358 | "password": ap_pass, | ||
| 359 | "game": "Lingo 2", | ||
| 360 | "name": ap_user, | ||
| 361 | "uuid": SCRIPT_uuid.v4(), | ||
| 362 | "version": ap_version, | ||
| 363 | "items_handling": 0b111, # always receive our items | ||
| 364 | "tags": [], | ||
| 365 | "slot_data": true | ||
| 366 | } | ||
| 367 | ] | ||
| 368 | ) | ||
| 369 | |||
| 370 | |||
| 371 | func sendConnectUpdate(tags): | ||
| 372 | sendMessage([{"cmd": "ConnectUpdate", "tags": tags}]) | ||
| 373 | |||
| 374 | |||
| 375 | func requestSync(): | ||
| 376 | sendMessage([{"cmd": "Sync"}]) | ||
| 377 | |||
| 378 | |||
| 379 | func sendLocation(loc_id): | ||
| 380 | sendMessage([{"cmd": "LocationChecks", "locations": [loc_id]}]) | ||
| 381 | |||
| 382 | |||
| 383 | func sendLocations(loc_ids): | ||
| 384 | sendMessage([{"cmd": "LocationChecks", "locations": loc_ids}]) | ||
| 385 | |||
| 386 | |||
| 387 | func setValue(key, value, operation = "replace"): | ||
| 388 | sendMessage( | ||
| 389 | [ | ||
| 390 | { | ||
| 391 | "cmd": "Set", | ||
| 392 | "key": "Lingo2_%d_%s" % [_slot, key], | ||
| 393 | "want_reply": false, | ||
| 394 | "operations": [{"operation": operation, "value": value}] | ||
| 395 | } | ||
| 396 | ] | ||
| 397 | ) | ||
| 398 | |||
| 399 | |||
| 400 | func say(textdata): | ||
| 401 | sendMessage([{"cmd": "Say", "text": textdata}]) | ||
| 402 | |||
| 403 | |||
| 404 | func completedGoal(): | ||
| 405 | sendMessage([{"cmd": "StatusUpdate", "status": 30}]) # CLIENT_GOAL | ||
| 406 | |||
| 407 | |||
| 408 | func scoutLocations(loc_ids): | ||
| 409 | sendMessage([{"cmd": "LocationScouts", "locations": loc_ids}]) | ||
| 410 | |||
| 411 | |||
| 412 | func hasItem(item_id): | ||
| 413 | return _received_items.has(item_id) | ||
| 414 | |||
| 415 | |||
| 416 | func getItemAmount(item_id): | ||
| 417 | return _received_items.get(item_id, 0) | ||
| diff --git a/client/Archipelago/collectable.gd b/client/Archipelago/collectable.gd deleted file mode 100644 index 4a17a2a..0000000 --- a/client/Archipelago/collectable.gd +++ /dev/null | |||
| @@ -1,16 +0,0 @@ | |||
| 1 | extends "res://scripts/nodes/collectable.gd" | ||
| 2 | |||
| 3 | |||
| 4 | func pickedUp(): | ||
| 5 | if unlock_type == "key": | ||
| 6 | var ap = global.get_node("Archipelago") | ||
| 7 | if ap.get_letter_behavior(unlock_key, level == 2) == ap.kLETTER_BEHAVIOR_VANILLA: | ||
| 8 | ap.keyboard.collect_local_letter(unlock_key, level) | ||
| 9 | else: | ||
| 10 | ap.keyboard.update_unlocks() | ||
| 11 | |||
| 12 | super.pickedUp() | ||
| 13 | |||
| 14 | |||
| 15 | func setScoutedText(text): | ||
| 16 | get_node("MeshInstance3D").mesh.text = text.replace(" ", "\n") | ||
| diff --git a/client/Archipelago/compass.gd b/client/Archipelago/compass.gd deleted file mode 100644 index c90475a..0000000 --- a/client/Archipelago/compass.gd +++ /dev/null | |||
| @@ -1,66 +0,0 @@ | |||
| 1 | extends Node2D | ||
| 2 | |||
| 3 | const RADIUS = 48 | ||
| 4 | |||
| 5 | var _font | ||
| 6 | |||
| 7 | |||
| 8 | func _ready(): | ||
| 9 | _font = load("res://assets/fonts/Lingo2.ttf") | ||
| 10 | |||
| 11 | |||
| 12 | func _draw(): | ||
| 13 | draw_circle(Vector2.ZERO, RADIUS, Color(1.0, 1.0, 1.0, 0.8), true) | ||
| 14 | draw_circle(Vector2.ZERO, RADIUS, Color.BLACK, false) | ||
| 15 | draw_string( | ||
| 16 | _font, | ||
| 17 | Vector2(-4, -RADIUS * 3.0 / 4.0), | ||
| 18 | "N", | ||
| 19 | HorizontalAlignment.HORIZONTAL_ALIGNMENT_LEFT, | ||
| 20 | -1, | ||
| 21 | 16, | ||
| 22 | Color.BLACK | ||
| 23 | ) | ||
| 24 | draw_set_transform(Vector2.ZERO, PI / 2) | ||
| 25 | draw_string( | ||
| 26 | _font, | ||
| 27 | Vector2(-4, -RADIUS * 3.0 / 4.0), | ||
| 28 | "E", | ||
| 29 | HorizontalAlignment.HORIZONTAL_ALIGNMENT_LEFT, | ||
| 30 | -1, | ||
| 31 | 16, | ||
| 32 | Color.BLACK | ||
| 33 | ) | ||
| 34 | draw_set_transform(Vector2.ZERO, PI) | ||
| 35 | draw_string( | ||
| 36 | _font, | ||
| 37 | Vector2(-4, -RADIUS * 3.0 / 4.0), | ||
| 38 | "S", | ||
| 39 | HorizontalAlignment.HORIZONTAL_ALIGNMENT_LEFT, | ||
| 40 | -1, | ||
| 41 | 16, | ||
| 42 | Color.BLACK | ||
| 43 | ) | ||
| 44 | draw_set_transform(Vector2.ZERO, PI * 3.0 / 2.0) | ||
| 45 | draw_string( | ||
| 46 | _font, | ||
| 47 | Vector2(-4, -RADIUS * 3.0 / 4.0), | ||
| 48 | "W", | ||
| 49 | HorizontalAlignment.HORIZONTAL_ALIGNMENT_LEFT, | ||
| 50 | -1, | ||
| 51 | 16, | ||
| 52 | Color.BLACK | ||
| 53 | ) | ||
| 54 | draw_set_transform(Vector2.ZERO) | ||
| 55 | draw_colored_polygon( | ||
| 56 | PackedVector2Array( | ||
| 57 | [Vector2(0, -RADIUS * 5.0 / 8.0), Vector2(-RADIUS / 6.0, 0), Vector2(RADIUS / 6.0, 0)] | ||
| 58 | ), | ||
| 59 | Color.RED | ||
| 60 | ) | ||
| 61 | draw_colored_polygon( | ||
| 62 | PackedVector2Array( | ||
| 63 | [Vector2(0, RADIUS * 5.0 / 8.0), Vector2(-RADIUS / 6.0, 0), Vector2(RADIUS / 6.0, 0)] | ||
| 64 | ), | ||
| 65 | Color.GRAY | ||
| 66 | ) | ||
| diff --git a/client/Archipelago/compass_overlay.gd b/client/Archipelago/compass_overlay.gd deleted file mode 100644 index 56e81ff..0000000 --- a/client/Archipelago/compass_overlay.gd +++ /dev/null | |||
| @@ -1,17 +0,0 @@ | |||
| 1 | extends CanvasLayer | ||
| 2 | |||
| 3 | var SCRIPT_compass | ||
| 4 | |||
| 5 | var compass | ||
| 6 | |||
| 7 | |||
| 8 | func _ready(): | ||
| 9 | compass = SCRIPT_compass.new() | ||
| 10 | compass.position = Vector2(1840, 80) | ||
| 11 | add_child(compass) | ||
| 12 | |||
| 13 | visible = false | ||
| 14 | |||
| 15 | |||
| 16 | func update_rotation(ry): | ||
| 17 | compass.rotation = ry | ||
| diff --git a/client/Archipelago/door.gd b/client/Archipelago/door.gd deleted file mode 100644 index 49f5728..0000000 --- a/client/Archipelago/door.gd +++ /dev/null | |||
| @@ -1,46 +0,0 @@ | |||
| 1 | extends "res://scripts/nodes/door.gd" | ||
| 2 | |||
| 3 | var item_id | ||
| 4 | var item_amount | ||
| 5 | |||
| 6 | |||
| 7 | func _ready(): | ||
| 8 | var node_path = String( | ||
| 9 | get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names() | ||
| 10 | ) | ||
| 11 | |||
| 12 | var gamedata = global.get_node("Gamedata") | ||
| 13 | var door_id = gamedata.get_door_for_map_node_path(global.map, node_path) | ||
| 14 | if door_id != null: | ||
| 15 | var ap = global.get_node("Archipelago") | ||
| 16 | var item_lock = ap.get_item_id_for_door(door_id) | ||
| 17 | |||
| 18 | if item_lock != null: | ||
| 19 | item_id = item_lock[0] | ||
| 20 | item_amount = item_lock[1] | ||
| 21 | |||
| 22 | self.senders = [] | ||
| 23 | self.senderGroup = [] | ||
| 24 | self.nested = false | ||
| 25 | self.complete_at = 0 | ||
| 26 | self.max_length = 0 | ||
| 27 | self.excludeSenders = [] | ||
| 28 | |||
| 29 | call_deferred("_readier") | ||
| 30 | |||
| 31 | if global.map == "the_sun_temple": | ||
| 32 | if name == "spe_EndPlatform" or name == "spe_entry_2": | ||
| 33 | senders = [NodePath("/root/scene/Panels/EndCheck_dog")] | ||
| 34 | |||
| 35 | if global.map == "the_parthenon": | ||
| 36 | if name == "spe_entry_1": | ||
| 37 | senders = [NodePath("/root/scene/Panels/EndCheck_dog")] | ||
| 38 | |||
| 39 | super._ready() | ||
| 40 | |||
| 41 | |||
| 42 | func _readier(): | ||
| 43 | var ap = global.get_node("Archipelago") | ||
| 44 | |||
| 45 | if ap.client.getItemAmount(item_id) >= item_amount: | ||
| 46 | handleTriggered() | ||
| diff --git a/client/Archipelago/gamedata.gd b/client/Archipelago/gamedata.gd deleted file mode 100644 index 9eeec3b..0000000 --- a/client/Archipelago/gamedata.gd +++ /dev/null | |||
| @@ -1,159 +0,0 @@ | |||
| 1 | extends Node | ||
| 2 | |||
| 3 | var SCRIPT_proto | ||
| 4 | |||
| 5 | var objects | ||
| 6 | var door_id_by_map_node_path = {} | ||
| 7 | var painting_id_by_map_node_path = {} | ||
| 8 | var panel_id_by_map_node_path = {} | ||
| 9 | var port_id_by_map_node_path = {} | ||
| 10 | var door_id_by_ap_id = {} | ||
| 11 | var map_id_by_name = {} | ||
| 12 | var progressive_id_by_ap_id = {} | ||
| 13 | var letter_id_by_ap_id = {} | ||
| 14 | var symbol_item_ids = [] | ||
| 15 | var anti_trap_ids = {} | ||
| 16 | |||
| 17 | var kSYMBOL_ITEMS | ||
| 18 | |||
| 19 | |||
| 20 | func _init(proto_script): | ||
| 21 | SCRIPT_proto = proto_script | ||
| 22 | |||
| 23 | kSYMBOL_ITEMS = { | ||
| 24 | SCRIPT_proto.PuzzleSymbol.SUN: "Sun Symbol", | ||
| 25 | SCRIPT_proto.PuzzleSymbol.SPARKLES: "Sparkles Symbol", | ||
| 26 | SCRIPT_proto.PuzzleSymbol.ZERO: "Zero Symbol", | ||
| 27 | SCRIPT_proto.PuzzleSymbol.EXAMPLE: "Example Symbol", | ||
| 28 | SCRIPT_proto.PuzzleSymbol.BOXES: "Boxes Symbol", | ||
| 29 | SCRIPT_proto.PuzzleSymbol.PLANET: "Planet Symbol", | ||
| 30 | SCRIPT_proto.PuzzleSymbol.PYRAMID: "Pyramid Symbol", | ||
| 31 | SCRIPT_proto.PuzzleSymbol.CROSS: "Cross Symbol", | ||
| 32 | SCRIPT_proto.PuzzleSymbol.SWEET: "Sweet Symbol", | ||
| 33 | SCRIPT_proto.PuzzleSymbol.GENDER: "Gender Symbol", | ||
| 34 | SCRIPT_proto.PuzzleSymbol.AGE: "Age Symbol", | ||
| 35 | SCRIPT_proto.PuzzleSymbol.SOUND: "Sound Symbol", | ||
| 36 | SCRIPT_proto.PuzzleSymbol.ANAGRAM: "Anagram Symbol", | ||
| 37 | SCRIPT_proto.PuzzleSymbol.JOB: "Job Symbol", | ||
| 38 | SCRIPT_proto.PuzzleSymbol.STARS: "Stars Symbol", | ||
| 39 | SCRIPT_proto.PuzzleSymbol.NULL: "Null Symbol", | ||
| 40 | SCRIPT_proto.PuzzleSymbol.EVAL: "Eval Symbol", | ||
| 41 | SCRIPT_proto.PuzzleSymbol.LINGO: "Lingo Symbol", | ||
| 42 | SCRIPT_proto.PuzzleSymbol.QUESTION: "Question Symbol", | ||
| 43 | } | ||
| 44 | |||
| 45 | |||
| 46 | func load(data_bytes): | ||
| 47 | objects = SCRIPT_proto.AllObjects.new() | ||
| 48 | |||
| 49 | var result_code = objects.from_bytes(data_bytes) | ||
| 50 | if result_code != SCRIPT_proto.PB_ERR.NO_ERRORS: | ||
| 51 | print("Could not load generated data: %d" % result_code) | ||
| 52 | return | ||
| 53 | |||
| 54 | for map in objects.get_maps(): | ||
| 55 | map_id_by_name[map.get_name()] = map.get_id() | ||
| 56 | |||
| 57 | for door in objects.get_doors(): | ||
| 58 | var map = objects.get_maps()[door.get_map_id()] | ||
| 59 | |||
| 60 | if not map.get_name() in door_id_by_map_node_path: | ||
| 61 | door_id_by_map_node_path[map.get_name()] = {} | ||
| 62 | |||
| 63 | var map_data = door_id_by_map_node_path[map.get_name()] | ||
| 64 | for receiver in door.get_receivers(): | ||
| 65 | map_data[receiver] = door.get_id() | ||
| 66 | |||
| 67 | for painting_id in door.get_move_paintings(): | ||
| 68 | var painting = objects.get_paintings()[painting_id] | ||
| 69 | map_data[painting.get_path()] = door.get_id() | ||
| 70 | |||
| 71 | if door.has_ap_id(): | ||
| 72 | door_id_by_ap_id[door.get_ap_id()] = door.get_id() | ||
| 73 | |||
| 74 | for painting in objects.get_paintings(): | ||
| 75 | var room = objects.get_rooms()[painting.get_room_id()] | ||
| 76 | var map = objects.get_maps()[room.get_map_id()] | ||
| 77 | |||
| 78 | if not map.get_name() in painting_id_by_map_node_path: | ||
| 79 | painting_id_by_map_node_path[map.get_name()] = {} | ||
| 80 | |||
| 81 | var _map_data = painting_id_by_map_node_path[map.get_name()] | ||
| 82 | |||
| 83 | for port in objects.get_ports(): | ||
| 84 | var room = objects.get_rooms()[port.get_room_id()] | ||
| 85 | var map = objects.get_maps()[room.get_map_id()] | ||
| 86 | |||
| 87 | if not map.get_name() in port_id_by_map_node_path: | ||
| 88 | port_id_by_map_node_path[map.get_name()] = {} | ||
| 89 | |||
| 90 | var map_data = port_id_by_map_node_path[map.get_name()] | ||
| 91 | map_data[port.get_path()] = port.get_id() | ||
| 92 | |||
| 93 | for progressive in objects.get_progressives(): | ||
| 94 | progressive_id_by_ap_id[progressive.get_ap_id()] = progressive.get_id() | ||
| 95 | |||
| 96 | for letter in objects.get_letters(): | ||
| 97 | letter_id_by_ap_id[letter.get_ap_id()] = letter.get_id() | ||
| 98 | |||
| 99 | for panel in objects.get_panels(): | ||
| 100 | var room = objects.get_rooms()[panel.get_room_id()] | ||
| 101 | var map = objects.get_maps()[room.get_map_id()] | ||
| 102 | |||
| 103 | if not map.get_name() in panel_id_by_map_node_path: | ||
| 104 | panel_id_by_map_node_path[map.get_name()] = {} | ||
| 105 | |||
| 106 | var map_data = panel_id_by_map_node_path[map.get_name()] | ||
| 107 | map_data[panel.get_path()] = panel.get_id() | ||
| 108 | |||
| 109 | for symbol_name in kSYMBOL_ITEMS.values(): | ||
| 110 | symbol_item_ids.append(objects.get_special_ids()[symbol_name]) | ||
| 111 | |||
| 112 | for special_name in objects.get_special_ids().keys(): | ||
| 113 | if special_name.begins_with("Anti "): | ||
| 114 | anti_trap_ids[objects.get_special_ids()[special_name]] = ( | ||
| 115 | special_name.substr(5).to_lower() | ||
| 116 | ) | ||
| 117 | |||
| 118 | |||
| 119 | func get_door_for_map_node_path(map_name, node_path): | ||
| 120 | if not door_id_by_map_node_path.has(map_name): | ||
| 121 | return null | ||
| 122 | |||
| 123 | var map_data = door_id_by_map_node_path[map_name] | ||
| 124 | return map_data.get(node_path, null) | ||
| 125 | |||
| 126 | |||
| 127 | func get_panel_for_map_node_path(map_name, node_path): | ||
| 128 | if not panel_id_by_map_node_path.has(map_name): | ||
| 129 | return null | ||
| 130 | |||
| 131 | var map_data = panel_id_by_map_node_path[map_name] | ||
| 132 | return map_data.get(node_path, null) | ||
| 133 | |||
| 134 | |||
| 135 | func get_port_for_map_node_path(map_name, node_path): | ||
| 136 | if not port_id_by_map_node_path.has(map_name): | ||
| 137 | return null | ||
| 138 | |||
| 139 | var map_data = port_id_by_map_node_path[map_name] | ||
| 140 | return map_data.get(node_path, null) | ||
| 141 | |||
| 142 | |||
| 143 | func get_door_ap_id(door_id): | ||
| 144 | var door = objects.get_doors()[door_id] | ||
| 145 | if door.has_ap_id(): | ||
| 146 | return door.get_ap_id() | ||
| 147 | else: | ||
| 148 | return null | ||
| 149 | |||
| 150 | |||
| 151 | func get_door_receivers(door_id): | ||
| 152 | var door = objects.get_doors()[door_id] | ||
| 153 | return door.get_receivers() | ||
| 154 | |||
| 155 | |||
| 156 | func get_door_map_name(door_id): | ||
| 157 | var door = objects.get_doors()[door_id] | ||
| 158 | var map = objects.get_maps()[door.get_map_id()] | ||
| 159 | return map.get_name() | ||
| diff --git a/client/Archipelago/keyHolder.gd b/client/Archipelago/keyHolder.gd deleted file mode 100644 index 3c037ff..0000000 --- a/client/Archipelago/keyHolder.gd +++ /dev/null | |||
| @@ -1,38 +0,0 @@ | |||
| 1 | extends "res://scripts/nodes/keyHolder.gd" | ||
| 2 | |||
| 3 | |||
| 4 | func setFromAp(key, level): | ||
| 5 | if level > 0: | ||
| 6 | has_key = true | ||
| 7 | is_complete = "%s%d" % [key, level] | ||
| 8 | held_key = key | ||
| 9 | held_level = level | ||
| 10 | get_node("Hinge/Letter").mesh.text = held_key | ||
| 11 | get_node("Hinge/Letter2").mesh.text = held_key | ||
| 12 | setMaterial() | ||
| 13 | emit_signal("trigger") | ||
| 14 | else: | ||
| 15 | has_key = false | ||
| 16 | held_key = "" | ||
| 17 | held_level = 0 | ||
| 18 | setMaterial() | ||
| 19 | get_node("Hinge/Letter").mesh.text = "-" | ||
| 20 | get_node("Hinge/Letter2").mesh.text = "-" | ||
| 21 | is_complete = "" | ||
| 22 | emit_signal("untrigger") | ||
| 23 | |||
| 24 | |||
| 25 | func addKey(key): | ||
| 26 | var node_path = String( | ||
| 27 | get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names() | ||
| 28 | ) | ||
| 29 | var ap = global.get_node("Archipelago") | ||
| 30 | ap.keyboard.put_in_keyholder(key, global.map, node_path) | ||
| 31 | |||
| 32 | |||
| 33 | func removeKey(): | ||
| 34 | var node_path = String( | ||
| 35 | get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names() | ||
| 36 | ) | ||
| 37 | var ap = global.get_node("Archipelago") | ||
| 38 | ap.keyboard.remove_from_keyholder(held_key, global.map, node_path) | ||
| diff --git a/client/Archipelago/keyHolderChecker.gd b/client/Archipelago/keyHolderChecker.gd deleted file mode 100644 index a75a9e4..0000000 --- a/client/Archipelago/keyHolderChecker.gd +++ /dev/null | |||
| @@ -1,24 +0,0 @@ | |||
| 1 | extends "res://scripts/nodes/listeners/keyHolderChecker.gd" | ||
| 2 | |||
| 3 | |||
| 4 | func check(): | ||
| 5 | var ap = global.get_node("Archipelago") | ||
| 6 | var matches = [] | ||
| 7 | for map in ap.keyboard.keyholder_state.keys(): | ||
| 8 | var nodes = ap.keyboard.keyholder_state[map] | ||
| 9 | for node in nodes.keys(): | ||
| 10 | matches.append([nodes[node], 1, map, "/root/scene/%s" % node]) | ||
| 11 | |||
| 12 | var count = 0 | ||
| 13 | for key_match in matches: | ||
| 14 | var active = ( | ||
| 15 | key_match[2] + String(key_match[3]).replace("/root/scene/Components/KeyHolders/", ".") | ||
| 16 | ) | ||
| 17 | if map[active] == key_match[0]: | ||
| 18 | emit_signal("trigger_letter", key_match[0], true) | ||
| 19 | count += 1 | ||
| 20 | else: | ||
| 21 | emit_signal("trigger_letter", key_match[0], false) | ||
| 22 | |||
| 23 | if count > 25: | ||
| 24 | emit_signal("trigger") | ||
| diff --git a/client/Archipelago/keyHolderResetterListener.gd b/client/Archipelago/keyHolderResetterListener.gd deleted file mode 100644 index d5300f3..0000000 --- a/client/Archipelago/keyHolderResetterListener.gd +++ /dev/null | |||
| @@ -1,8 +0,0 @@ | |||
| 1 | extends "res://scripts/nodes/listeners/keyHolderResetterListener.gd" | ||
| 2 | |||
| 3 | |||
| 4 | func reset(): | ||
| 5 | var ap = global.get_node("Archipelago") | ||
| 6 | var was_removed = ap.keyboard.reset_keyholders() | ||
| 7 | if was_removed: | ||
| 8 | sfxPlayer.sfx_play("pickup") | ||
| diff --git a/client/Archipelago/keyboard.gd b/client/Archipelago/keyboard.gd deleted file mode 100644 index 450566d..0000000 --- a/client/Archipelago/keyboard.gd +++ /dev/null | |||
| @@ -1,199 +0,0 @@ | |||
| 1 | extends Node | ||
| 2 | |||
| 3 | const kALL_LETTERS = "abcdefghjiklmnopqrstuvwxyz" | ||
| 4 | |||
| 5 | var letters_saved = {} | ||
| 6 | var letters_in_keyholders = [] | ||
| 7 | var letters_blocked = [] | ||
| 8 | var letters_dynamic = {} | ||
| 9 | var keyholder_state = {} | ||
| 10 | |||
| 11 | var filename = "" | ||
| 12 | |||
| 13 | |||
| 14 | func _init(): | ||
| 15 | reset() | ||
| 16 | |||
| 17 | |||
| 18 | func reset(): | ||
| 19 | letters_saved.clear() | ||
| 20 | letters_in_keyholders.clear() | ||
| 21 | letters_blocked.clear() | ||
| 22 | letters_dynamic.clear() | ||
| 23 | keyholder_state.clear() | ||
| 24 | |||
| 25 | |||
| 26 | func load_seed(): | ||
| 27 | var ap = global.get_node("Archipelago") | ||
| 28 | |||
| 29 | reset() | ||
| 30 | |||
| 31 | filename = "user://archipelago_keys/%s_%d" % [ap.client._seed, ap.client._slot] | ||
| 32 | |||
| 33 | if FileAccess.file_exists(filename): | ||
| 34 | var ap_file = FileAccess.open(filename, FileAccess.READ) | ||
| 35 | var localdata = [] | ||
| 36 | if ap_file != null: | ||
| 37 | localdata = ap_file.get_var(true) | ||
| 38 | ap_file.close() | ||
| 39 | |||
| 40 | if typeof(localdata) != TYPE_ARRAY: | ||
| 41 | print("AP keyboard file is corrupted") | ||
| 42 | localdata = [] | ||
| 43 | |||
| 44 | if localdata.size() > 0: | ||
| 45 | letters_saved = localdata[0] | ||
| 46 | if localdata.size() > 1: | ||
| 47 | letters_in_keyholders = localdata[1] | ||
| 48 | if localdata.size() > 2: | ||
| 49 | keyholder_state = localdata[2] | ||
| 50 | |||
| 51 | for k in kALL_LETTERS: | ||
| 52 | var level = 0 | ||
| 53 | |||
| 54 | if ap.get_letter_behavior(k, false) == ap.kLETTER_BEHAVIOR_UNLOCKED: | ||
| 55 | level += 1 | ||
| 56 | if ap.get_letter_behavior(k, true) == ap.kLETTER_BEHAVIOR_UNLOCKED: | ||
| 57 | level += 1 | ||
| 58 | |||
| 59 | letters_dynamic[k] = level | ||
| 60 | |||
| 61 | update_unlocks() | ||
| 62 | |||
| 63 | |||
| 64 | func save(): | ||
| 65 | var dir = DirAccess.open("user://") | ||
| 66 | var folder = "archipelago_keys" | ||
| 67 | if not dir.dir_exists(folder): | ||
| 68 | dir.make_dir(folder) | ||
| 69 | |||
| 70 | var file = FileAccess.open(filename, FileAccess.WRITE) | ||
| 71 | |||
| 72 | var data = [ | ||
| 73 | letters_saved, | ||
| 74 | letters_in_keyholders, | ||
| 75 | keyholder_state, | ||
| 76 | ] | ||
| 77 | file.store_var(data, true) | ||
| 78 | file.close() | ||
| 79 | |||
| 80 | |||
| 81 | func update_unlocks(): | ||
| 82 | unlocks.resetKeys() | ||
| 83 | |||
| 84 | var has_doubles = false | ||
| 85 | |||
| 86 | for k in kALL_LETTERS: | ||
| 87 | var level = 0 | ||
| 88 | |||
| 89 | if not letters_in_keyholders.has(k): | ||
| 90 | level = letters_saved.get(k, 0) + letters_dynamic.get(k, 0) | ||
| 91 | |||
| 92 | if level >= 2: | ||
| 93 | level = 2 | ||
| 94 | has_doubles = true | ||
| 95 | |||
| 96 | if letters_blocked.has(k): | ||
| 97 | level = 0 | ||
| 98 | |||
| 99 | unlocks.unlockKey(k, level) | ||
| 100 | |||
| 101 | if has_doubles and unlocks.data["double_letters"] != "unlocked": | ||
| 102 | var ap = global.get_node("Archipelago") | ||
| 103 | if ap.cyan_door_behavior == ap.kCYAN_DOOR_BEHAVIOR_DOUBLE_LETTER: | ||
| 104 | unlocks.setData("double_letters", "unlocked") | ||
| 105 | |||
| 106 | |||
| 107 | func collect_local_letter(key, level): | ||
| 108 | if level < 0 or level > 2 or level < letters_saved.get(key, 0): | ||
| 109 | return | ||
| 110 | |||
| 111 | letters_saved[key] = level | ||
| 112 | |||
| 113 | if letters_blocked.has(key): | ||
| 114 | letters_blocked.erase(key) | ||
| 115 | |||
| 116 | update_unlocks() | ||
| 117 | save() | ||
| 118 | |||
| 119 | |||
| 120 | func collect_remote_letter(key, level): | ||
| 121 | if level < 0 or level > 2 or level < letters_dynamic.get(key, 0): | ||
| 122 | return | ||
| 123 | |||
| 124 | letters_dynamic[key] = level | ||
| 125 | |||
| 126 | if letters_blocked.has(key): | ||
| 127 | letters_blocked.erase(key) | ||
| 128 | |||
| 129 | update_unlocks() | ||
| 130 | save() | ||
| 131 | |||
| 132 | |||
| 133 | func put_in_keyholder(key, map, kh_path): | ||
| 134 | if not keyholder_state.has(map): | ||
| 135 | keyholder_state[map] = {} | ||
| 136 | |||
| 137 | keyholder_state[map][kh_path] = key | ||
| 138 | letters_in_keyholders.append(key) | ||
| 139 | |||
| 140 | get_tree().get_root().get_node("scene").get_node(kh_path).setFromAp( | ||
| 141 | key, min(letters_saved.get(key, 0) + letters_dynamic.get(key, 0), 2) | ||
| 142 | ) | ||
| 143 | |||
| 144 | update_unlocks() | ||
| 145 | save() | ||
| 146 | |||
| 147 | |||
| 148 | func remove_from_keyholder(key, map, kh_path): | ||
| 149 | if not keyholder_state.has(map): | ||
| 150 | # This... shouldn't happen. | ||
| 151 | keyholder_state[map] = {} | ||
| 152 | |||
| 153 | keyholder_state[map].erase(kh_path) | ||
| 154 | letters_in_keyholders.erase(key) | ||
| 155 | |||
| 156 | get_tree().get_root().get_node("scene").get_node(kh_path).setFromAp(key, 0) | ||
| 157 | |||
| 158 | update_unlocks() | ||
| 159 | save() | ||
| 160 | |||
| 161 | |||
| 162 | func block_letter(key): | ||
| 163 | if not letters_blocked.has(key): | ||
| 164 | letters_blocked.append(key) | ||
| 165 | |||
| 166 | update_unlocks() | ||
| 167 | |||
| 168 | |||
| 169 | func load_keyholders(map): | ||
| 170 | if keyholder_state.has(map): | ||
| 171 | var khs = keyholder_state[map] | ||
| 172 | |||
| 173 | for path in khs.keys(): | ||
| 174 | var key = khs[path] | ||
| 175 | get_tree().get_root().get_node("scene").get_node(path).setFromAp( | ||
| 176 | key, min(letters_saved.get(key, 0) + letters_dynamic.get(key, 0), 2) | ||
| 177 | ) | ||
| 178 | |||
| 179 | |||
| 180 | func reset_keyholders(): | ||
| 181 | if letters_in_keyholders.is_empty() and letters_blocked.is_empty(): | ||
| 182 | return false | ||
| 183 | |||
| 184 | var cleared_anything = not letters_in_keyholders.is_empty() or not letters_blocked.is_empty() | ||
| 185 | |||
| 186 | if keyholder_state.has(global.map): | ||
| 187 | for path in keyholder_state[global.map]: | ||
| 188 | get_tree().get_root().get_node("scene").get_node(path).setFromAp( | ||
| 189 | keyholder_state[global.map][path], 0 | ||
| 190 | ) | ||
| 191 | |||
| 192 | keyholder_state.clear() | ||
| 193 | letters_in_keyholders.clear() | ||
| 194 | letters_blocked.clear() | ||
| 195 | |||
| 196 | update_unlocks() | ||
| 197 | save() | ||
| 198 | |||
| 199 | return cleared_anything | ||
| diff --git a/client/Archipelago/locationListener.gd b/client/Archipelago/locationListener.gd deleted file mode 100644 index 71792ed..0000000 --- a/client/Archipelago/locationListener.gd +++ /dev/null | |||
| @@ -1,20 +0,0 @@ | |||
| 1 | extends Receiver | ||
| 2 | |||
| 3 | var location_id | ||
| 4 | |||
| 5 | |||
| 6 | func _ready(): | ||
| 7 | super._ready() | ||
| 8 | |||
| 9 | |||
| 10 | func handleTriggered(): | ||
| 11 | triggered += 1 | ||
| 12 | if triggered >= total: | ||
| 13 | var ap = global.get_node("Archipelago") | ||
| 14 | ap.send_location(location_id) | ||
| 15 | |||
| 16 | |||
| 17 | func handleUntriggered(): | ||
| 18 | triggered -= 1 | ||
| 19 | if triggered < total: | ||
| 20 | pass | ||
| diff --git a/client/Archipelago/manager.gd b/client/Archipelago/manager.gd deleted file mode 100644 index b170c77..0000000 --- a/client/Archipelago/manager.gd +++ /dev/null | |||
| @@ -1,571 +0,0 @@ | |||
| 1 | extends Node | ||
| 2 | |||
| 3 | const MOD_VERSION = 7 | ||
| 4 | |||
| 5 | var SCRIPT_client | ||
| 6 | var SCRIPT_keyboard | ||
| 7 | var SCRIPT_locationListener | ||
| 8 | var SCRIPT_minimap | ||
| 9 | var SCRIPT_uuid | ||
| 10 | var SCRIPT_victoryListener | ||
| 11 | |||
| 12 | var ap_server = "" | ||
| 13 | var ap_user = "" | ||
| 14 | var ap_pass = "" | ||
| 15 | var connection_history = [] | ||
| 16 | var show_compass = false | ||
| 17 | |||
| 18 | var client | ||
| 19 | var keyboard | ||
| 20 | |||
| 21 | var _localdata_file = "" | ||
| 22 | var _last_new_item = -1 | ||
| 23 | var _batch_locations = false | ||
| 24 | var _held_locations = [] | ||
| 25 | var _held_location_scouts = [] | ||
| 26 | var _location_scouts = {} | ||
| 27 | var _item_locks = {} | ||
| 28 | var _inverse_item_locks = {} | ||
| 29 | var _held_letters = {} | ||
| 30 | var _letters_setup = false | ||
| 31 | |||
| 32 | const kSHUFFLE_LETTERS_VANILLA = 0 | ||
| 33 | const kSHUFFLE_LETTERS_UNLOCKED = 1 | ||
| 34 | const kSHUFFLE_LETTERS_PROGRESSIVE = 2 | ||
| 35 | const kSHUFFLE_LETTERS_VANILLA_CYAN = 3 | ||
| 36 | const kSHUFFLE_LETTERS_ITEM_CYAN = 4 | ||
| 37 | |||
| 38 | const kLETTER_BEHAVIOR_VANILLA = 0 | ||
| 39 | const kLETTER_BEHAVIOR_ITEM = 1 | ||
| 40 | const kLETTER_BEHAVIOR_UNLOCKED = 2 | ||
| 41 | |||
| 42 | const kCYAN_DOOR_BEHAVIOR_H2 = 0 | ||
| 43 | const kCYAN_DOOR_BEHAVIOR_DOUBLE_LETTER = 1 | ||
| 44 | const kCYAN_DOOR_BEHAVIOR_ITEM = 2 | ||
| 45 | |||
| 46 | var apworld_version = [0, 0] | ||
| 47 | var cyan_door_behavior = kCYAN_DOOR_BEHAVIOR_H2 | ||
| 48 | var daedalus_roof_access = false | ||
| 49 | var keyholder_sanity = false | ||
| 50 | var port_pairings = {} | ||
| 51 | var shuffle_control_center_colors = false | ||
| 52 | var shuffle_doors = false | ||
| 53 | var shuffle_gallery_paintings = false | ||
| 54 | var shuffle_letters = kSHUFFLE_LETTERS_VANILLA | ||
| 55 | var shuffle_symbols = false | ||
| 56 | var shuffle_worldports = false | ||
| 57 | var strict_cyan_ending = false | ||
| 58 | var strict_purple_ending = false | ||
| 59 | var victory_condition = -1 | ||
| 60 | |||
| 61 | signal could_not_connect | ||
| 62 | signal connect_status | ||
| 63 | signal ap_connected | ||
| 64 | |||
| 65 | |||
| 66 | func _init(): | ||
| 67 | # Read AP settings from file, if there are any | ||
| 68 | if FileAccess.file_exists("user://ap_settings"): | ||
| 69 | var file = FileAccess.open("user://ap_settings", FileAccess.READ) | ||
| 70 | var data = file.get_var(true) | ||
| 71 | file.close() | ||
| 72 | |||
| 73 | if typeof(data) != TYPE_ARRAY: | ||
| 74 | global._print("AP settings file is corrupted") | ||
| 75 | data = [] | ||
| 76 | |||
| 77 | if data.size() > 0: | ||
| 78 | ap_server = data[0] | ||
| 79 | |||
| 80 | if data.size() > 1: | ||
| 81 | ap_user = data[1] | ||
| 82 | |||
| 83 | if data.size() > 2: | ||
| 84 | ap_pass = data[2] | ||
| 85 | |||
| 86 | if data.size() > 3: | ||
| 87 | connection_history = data[3] | ||
| 88 | |||
| 89 | if data.size() > 4: | ||
| 90 | show_compass = data[4] | ||
| 91 | |||
| 92 | |||
| 93 | func _ready(): | ||
| 94 | client = SCRIPT_client.new() | ||
| 95 | client.SCRIPT_uuid = SCRIPT_uuid | ||
| 96 | |||
| 97 | client.connect("item_received", _process_item) | ||
| 98 | client.connect("message_received", _process_message) | ||
| 99 | client.connect("location_scout_received", _process_location_scout) | ||
| 100 | client.connect("could_not_connect", _client_could_not_connect) | ||
| 101 | client.connect("connect_status", _client_connect_status) | ||
| 102 | client.connect("client_connected", _client_connected) | ||
| 103 | |||
| 104 | add_child(client) | ||
| 105 | |||
| 106 | keyboard = SCRIPT_keyboard.new() | ||
| 107 | add_child(keyboard) | ||
| 108 | |||
| 109 | |||
| 110 | func saveSettings(): | ||
| 111 | # Save the AP settings to disk. | ||
| 112 | var path = "user://ap_settings" | ||
| 113 | var file = FileAccess.open(path, FileAccess.WRITE) | ||
| 114 | |||
| 115 | var data = [ | ||
| 116 | ap_server, | ||
| 117 | ap_user, | ||
| 118 | ap_pass, | ||
| 119 | connection_history, | ||
| 120 | show_compass, | ||
| 121 | ] | ||
| 122 | file.store_var(data, true) | ||
| 123 | file.close() | ||
| 124 | |||
| 125 | |||
| 126 | func saveLocaldata(): | ||
| 127 | # Save the MW/slot specific settings to disk. | ||
| 128 | var dir = DirAccess.open("user://") | ||
| 129 | var folder = "archipelago_data" | ||
| 130 | if not dir.dir_exists(folder): | ||
| 131 | dir.make_dir(folder) | ||
| 132 | |||
| 133 | var file = FileAccess.open(_localdata_file, FileAccess.WRITE) | ||
| 134 | |||
| 135 | var data = [ | ||
| 136 | _last_new_item, | ||
| 137 | ] | ||
| 138 | file.store_var(data, true) | ||
| 139 | file.close() | ||
| 140 | |||
| 141 | |||
| 142 | func connectToServer(): | ||
| 143 | _last_new_item = -1 | ||
| 144 | _batch_locations = false | ||
| 145 | _held_locations = [] | ||
| 146 | _held_location_scouts = [] | ||
| 147 | _location_scouts = {} | ||
| 148 | _letters_setup = false | ||
| 149 | _held_letters = {} | ||
| 150 | |||
| 151 | client.connectToServer(ap_server, ap_user, ap_pass) | ||
| 152 | |||
| 153 | |||
| 154 | func getSaveFileName(): | ||
| 155 | return "zzAP_%s_%d" % [client._seed, client._slot] | ||
| 156 | |||
| 157 | |||
| 158 | func disconnect_from_ap(): | ||
| 159 | client.disconnect_from_ap() | ||
| 160 | |||
| 161 | |||
| 162 | func get_item_id_for_door(door_id): | ||
| 163 | return _item_locks.get(door_id, null) | ||
| 164 | |||
| 165 | |||
| 166 | func _process_item(item, index, from, flags, amount): | ||
| 167 | var item_name = "Unknown" | ||
| 168 | if client._item_id_to_name["Lingo 2"].has(item): | ||
| 169 | item_name = client._item_id_to_name["Lingo 2"][item] | ||
| 170 | |||
| 171 | var gamedata = global.get_node("Gamedata") | ||
| 172 | |||
| 173 | var prog_id = null | ||
| 174 | if _inverse_item_locks.has(item): | ||
| 175 | for lock in _inverse_item_locks.get(item): | ||
| 176 | if lock[1] != amount: | ||
| 177 | continue | ||
| 178 | |||
| 179 | if gamedata.progressive_id_by_ap_id.has(item): | ||
| 180 | prog_id = lock[0] | ||
| 181 | |||
| 182 | if gamedata.get_door_map_name(lock[0]) != global.map: | ||
| 183 | continue | ||
| 184 | |||
| 185 | var receivers = gamedata.get_door_receivers(lock[0]) | ||
| 186 | var scene = get_tree().get_root().get_node_or_null("scene") | ||
| 187 | if scene != null: | ||
| 188 | for receiver in receivers: | ||
| 189 | var rnode = scene.get_node_or_null(receiver) | ||
| 190 | if rnode != null: | ||
| 191 | rnode.handleTriggered() | ||
| 192 | |||
| 193 | var letter_id = gamedata.letter_id_by_ap_id.get(item, null) | ||
| 194 | if letter_id != null: | ||
| 195 | var letter = gamedata.objects.get_letters()[letter_id] | ||
| 196 | if not letter.has_level2() or not letter.get_level2(): | ||
| 197 | _process_key_item(letter.get_key(), amount) | ||
| 198 | |||
| 199 | if gamedata.symbol_item_ids.has(item): | ||
| 200 | var player = get_tree().get_root().get_node_or_null("scene/player") | ||
| 201 | if player != null: | ||
| 202 | player.emit_signal("evaluate_solvability") | ||
| 203 | |||
| 204 | # Show a message about the item if it's new. | ||
| 205 | if index != null and index > _last_new_item: | ||
| 206 | _last_new_item = index | ||
| 207 | saveLocaldata() | ||
| 208 | |||
| 209 | var player_name = "Unknown" | ||
| 210 | if client._player_name_by_slot.has(float(from)): | ||
| 211 | player_name = client._player_name_by_slot[float(from)] | ||
| 212 | |||
| 213 | var full_item_name = item_name | ||
| 214 | if prog_id != null: | ||
| 215 | var door = gamedata.objects.get_doors()[prog_id] | ||
| 216 | full_item_name = "%s (%s)" % [item_name, door.get_name()] | ||
| 217 | |||
| 218 | var message | ||
| 219 | if from == client._slot: | ||
| 220 | message = "Found %s" % wrapInItemColorTags(full_item_name, flags) | ||
| 221 | else: | ||
| 222 | message = ( | ||
| 223 | "Received %s from %s" % [wrapInItemColorTags(full_item_name, flags), player_name] | ||
| 224 | ) | ||
| 225 | |||
| 226 | if gamedata.anti_trap_ids.has(item): | ||
| 227 | keyboard.block_letter(gamedata.anti_trap_ids[item]) | ||
| 228 | |||
| 229 | global._print(message) | ||
| 230 | |||
| 231 | global.get_node("Messages").showMessage(message) | ||
| 232 | |||
| 233 | |||
| 234 | func _process_message(message): | ||
| 235 | parse_printjson_for_textclient(message) | ||
| 236 | |||
| 237 | if ( | ||
| 238 | !message.has("receiving") | ||
| 239 | or !message.has("item") | ||
| 240 | or message["item"]["player"] != client._slot | ||
| 241 | ): | ||
| 242 | return | ||
| 243 | |||
| 244 | var item_name = "Unknown" | ||
| 245 | var item_player_game = client._game_by_player[message["receiving"]] | ||
| 246 | if client._item_id_to_name[item_player_game].has(int(message["item"]["item"])): | ||
| 247 | item_name = client._item_id_to_name[item_player_game][int(message["item"]["item"])] | ||
| 248 | |||
| 249 | var location_name = "Unknown" | ||
| 250 | var location_player_game = client._game_by_player[message["item"]["player"]] | ||
| 251 | if client._location_id_to_name[location_player_game].has(int(message["item"]["location"])): | ||
| 252 | location_name = (client._location_id_to_name[location_player_game][int( | ||
| 253 | message["item"]["location"] | ||
| 254 | )]) | ||
| 255 | |||
| 256 | var player_name = "Unknown" | ||
| 257 | if client._player_name_by_slot.has(message["receiving"]): | ||
| 258 | player_name = client._player_name_by_slot[message["receiving"]] | ||
| 259 | |||
| 260 | var item_color = colorForItemType(message["item"]["flags"]) | ||
| 261 | |||
| 262 | if message["type"] == "Hint": | ||
| 263 | var is_for = "" | ||
| 264 | if message["receiving"] != client._slot: | ||
| 265 | is_for = " for %s" % player_name | ||
| 266 | if !message.has("found") || !message["found"]: | ||
| 267 | global.get_node("Messages").showMessage( | ||
| 268 | ( | ||
| 269 | "Hint: %s%s is on %s" | ||
| 270 | % [ | ||
| 271 | wrapInItemColorTags(item_name, message["item"]["flags"]), | ||
| 272 | is_for, | ||
| 273 | location_name | ||
| 274 | ] | ||
| 275 | ) | ||
| 276 | ) | ||
| 277 | else: | ||
| 278 | if message["receiving"] != client._slot: | ||
| 279 | var sentMsg = ( | ||
| 280 | "Sent %s to %s" | ||
| 281 | % [wrapInItemColorTags(item_name, message["item"]["flags"]), player_name] | ||
| 282 | ) | ||
| 283 | #if _hinted_locations.has(message["item"]["location"]): | ||
| 284 | # sentMsg += " ([color=#fafad2]Hinted![/color])" | ||
| 285 | global.get_node("Messages").showMessage(sentMsg) | ||
| 286 | |||
| 287 | |||
| 288 | func parse_printjson_for_textclient(message): | ||
| 289 | var parts = [] | ||
| 290 | for message_part in message["data"]: | ||
| 291 | if !message_part.has("type") and message_part.has("text"): | ||
| 292 | parts.append(message_part["text"]) | ||
| 293 | elif message_part["type"] == "player_id": | ||
| 294 | if int(message_part["text"]) == client._slot: | ||
| 295 | parts.append( | ||
| 296 | "[color=#ee00ee]%s[/color]" % client._player_name_by_slot[client._slot] | ||
| 297 | ) | ||
| 298 | else: | ||
| 299 | var from = float(message_part["text"]) | ||
| 300 | parts.append("[color=#fafad2]%s[/color]" % client._player_name_by_slot[from]) | ||
| 301 | elif message_part["type"] == "item_id": | ||
| 302 | var item_name = "Unknown" | ||
| 303 | var item_player_game = client._game_by_player[message_part["player"]] | ||
| 304 | if client._item_id_to_name[item_player_game].has(int(message_part["text"])): | ||
| 305 | item_name = client._item_id_to_name[item_player_game][int(message_part["text"])] | ||
| 306 | |||
| 307 | parts.append(wrapInItemColorTags(item_name, message_part["flags"])) | ||
| 308 | elif message_part["type"] == "location_id": | ||
| 309 | var location_name = "Unknown" | ||
| 310 | var location_player_game = client._game_by_player[message_part["player"]] | ||
| 311 | if client._location_id_to_name[location_player_game].has(int(message_part["text"])): | ||
| 312 | location_name = client._location_id_to_name[location_player_game][int( | ||
| 313 | message_part["text"] | ||
| 314 | )] | ||
| 315 | |||
| 316 | parts.append("[color=#00ff7f]%s[/color]" % location_name) | ||
| 317 | elif message_part.has("text"): | ||
| 318 | parts.append(message_part["text"]) | ||
| 319 | |||
| 320 | var textclient_node = global.get_node("Textclient") | ||
| 321 | if textclient_node != null: | ||
| 322 | textclient_node.parse_printjson("".join(parts)) | ||
| 323 | |||
| 324 | |||
| 325 | func _process_location_scout(item_id, location_id, player, flags): | ||
| 326 | _location_scouts[location_id] = {"item": item_id, "player": player, "flags": flags} | ||
| 327 | |||
| 328 | if player == client._slot and flags & 4 != 0: | ||
| 329 | # This is a trap for us, so let's not display it. | ||
| 330 | return | ||
| 331 | |||
| 332 | var gamedata = global.get_node("Gamedata") | ||
| 333 | var map_id = gamedata.map_id_by_name.get(global.map) | ||
| 334 | |||
| 335 | var item_name = "Unknown" | ||
| 336 | var item_player_game = client._game_by_player[float(player)] | ||
| 337 | if client._item_id_to_name[item_player_game].has(item_id): | ||
| 338 | item_name = client._item_id_to_name[item_player_game][item_id] | ||
| 339 | |||
| 340 | var letter_id = gamedata.letter_id_by_ap_id.get(location_id, null) | ||
| 341 | if letter_id != null: | ||
| 342 | var letter = gamedata.objects.get_letters()[letter_id] | ||
| 343 | var room = gamedata.objects.get_rooms()[letter.get_room_id()] | ||
| 344 | if room.get_map_id() == map_id: | ||
| 345 | var collectable = get_tree().get_root().get_node("scene").get_node_or_null( | ||
| 346 | letter.get_path() | ||
| 347 | ) | ||
| 348 | if collectable != null: | ||
| 349 | collectable.setScoutedText(item_name) | ||
| 350 | |||
| 351 | |||
| 352 | func _client_could_not_connect(message): | ||
| 353 | emit_signal("could_not_connect", message) | ||
| 354 | |||
| 355 | |||
| 356 | func _client_connect_status(message): | ||
| 357 | emit_signal("connect_status", message) | ||
| 358 | |||
| 359 | |||
| 360 | func _client_connected(slot_data): | ||
| 361 | var gamedata = global.get_node("Gamedata") | ||
| 362 | |||
| 363 | _localdata_file = "user://archipelago_data/%s_%d" % [client._seed, client._slot] | ||
| 364 | _last_new_item = -1 | ||
| 365 | |||
| 366 | if FileAccess.file_exists(_localdata_file): | ||
| 367 | var ap_file = FileAccess.open(_localdata_file, FileAccess.READ) | ||
| 368 | var localdata = [] | ||
| 369 | if ap_file != null: | ||
| 370 | localdata = ap_file.get_var(true) | ||
| 371 | ap_file.close() | ||
| 372 | |||
| 373 | if typeof(localdata) != TYPE_ARRAY: | ||
| 374 | print("AP localdata file is corrupted") | ||
| 375 | localdata = [] | ||
| 376 | |||
| 377 | if localdata.size() > 0: | ||
| 378 | _last_new_item = localdata[0] | ||
| 379 | |||
| 380 | # Read slot data. | ||
| 381 | cyan_door_behavior = int(slot_data.get("cyan_door_behavior", 0)) | ||
| 382 | daedalus_roof_access = bool(slot_data.get("daedalus_roof_access", false)) | ||
| 383 | keyholder_sanity = bool(slot_data.get("keyholder_sanity", false)) | ||
| 384 | shuffle_control_center_colors = bool(slot_data.get("shuffle_control_center_colors", false)) | ||
| 385 | shuffle_doors = bool(slot_data.get("shuffle_doors", false)) | ||
| 386 | shuffle_gallery_paintings = bool(slot_data.get("shuffle_gallery_paintings", false)) | ||
| 387 | shuffle_letters = int(slot_data.get("shuffle_letters", 0)) | ||
| 388 | shuffle_symbols = bool(slot_data.get("shuffle_symbols", false)) | ||
| 389 | shuffle_worldports = bool(slot_data.get("shuffle_worldports", false)) | ||
| 390 | strict_cyan_ending = bool(slot_data.get("strict_cyan_ending", false)) | ||
| 391 | strict_purple_ending = bool(slot_data.get("strict_purple_ending", false)) | ||
| 392 | victory_condition = int(slot_data.get("victory_condition", 0)) | ||
| 393 | |||
| 394 | if slot_data.has("version"): | ||
| 395 | apworld_version = [int(slot_data["version"][0]), int(slot_data["version"][1])] | ||
| 396 | |||
| 397 | port_pairings.clear() | ||
| 398 | if slot_data.has("port_pairings"): | ||
| 399 | var raw_pp = slot_data.get("port_pairings") | ||
| 400 | |||
| 401 | for p1 in raw_pp.keys(): | ||
| 402 | port_pairings[int(p1)] = int(raw_pp[p1]) | ||
| 403 | |||
| 404 | # Set up item locks. | ||
| 405 | _item_locks = {} | ||
| 406 | |||
| 407 | if shuffle_doors: | ||
| 408 | for door in gamedata.objects.get_doors(): | ||
| 409 | if ( | ||
| 410 | door.get_type() == gamedata.SCRIPT_proto.DoorType.STANDARD | ||
| 411 | or door.get_type() == gamedata.SCRIPT_proto.DoorType.ITEM_ONLY | ||
| 412 | ): | ||
| 413 | _item_locks[door.get_id()] = [door.get_ap_id(), 1] | ||
| 414 | |||
| 415 | for progressive in gamedata.objects.get_progressives(): | ||
| 416 | for i in range(0, progressive.get_doors().size()): | ||
| 417 | var door = gamedata.objects.get_doors()[progressive.get_doors()[i]] | ||
| 418 | _item_locks[door.get_id()] = [progressive.get_ap_id(), i + 1] | ||
| 419 | |||
| 420 | for door_group in gamedata.objects.get_door_groups(): | ||
| 421 | if door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.CONNECTOR: | ||
| 422 | if shuffle_worldports: | ||
| 423 | continue | ||
| 424 | elif door_group.get_type() != gamedata.SCRIPT_proto.DoorGroupType.SHUFFLE_GROUP: | ||
| 425 | continue | ||
| 426 | |||
| 427 | for door in door_group.get_doors(): | ||
| 428 | _item_locks[door] = [door_group.get_ap_id(), 1] | ||
| 429 | |||
| 430 | if shuffle_control_center_colors: | ||
| 431 | for door in gamedata.objects.get_doors(): | ||
| 432 | if door.get_type() == gamedata.SCRIPT_proto.DoorType.CONTROL_CENTER_COLOR: | ||
| 433 | _item_locks[door.get_id()] = [door.get_ap_id(), 1] | ||
| 434 | |||
| 435 | for door_group in gamedata.objects.get_door_groups(): | ||
| 436 | if ( | ||
| 437 | door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.COLOR_CONNECTOR | ||
| 438 | and not shuffle_worldports | ||
| 439 | ): | ||
| 440 | for door in door_group.get_doors(): | ||
| 441 | _item_locks[door] = [door_group.get_ap_id(), 1] | ||
| 442 | |||
| 443 | if shuffle_gallery_paintings: | ||
| 444 | for door in gamedata.objects.get_doors(): | ||
| 445 | if door.get_type() == gamedata.SCRIPT_proto.DoorType.GALLERY_PAINTING: | ||
| 446 | _item_locks[door.get_id()] = [door.get_ap_id(), 1] | ||
| 447 | |||
| 448 | if cyan_door_behavior == kCYAN_DOOR_BEHAVIOR_ITEM: | ||
| 449 | for door_group in gamedata.objects.get_door_groups(): | ||
| 450 | if door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.CYAN_DOORS: | ||
| 451 | for door in door_group.get_doors(): | ||
| 452 | if not _item_locks.has(door): | ||
| 453 | _item_locks[door] = [door_group.get_ap_id(), 1] | ||
| 454 | |||
| 455 | # Create a reverse item locks map for processing items. | ||
| 456 | _inverse_item_locks = {} | ||
| 457 | |||
| 458 | for door_id in _item_locks.keys(): | ||
| 459 | var lock = _item_locks.get(door_id) | ||
| 460 | |||
| 461 | if not _inverse_item_locks.has(lock[0]): | ||
| 462 | _inverse_item_locks[lock[0]] = [] | ||
| 463 | |||
| 464 | _inverse_item_locks[lock[0]].append([door_id, lock[1]]) | ||
| 465 | |||
| 466 | emit_signal("ap_connected") | ||
| 467 | |||
| 468 | |||
| 469 | func start_batching_locations(): | ||
| 470 | _batch_locations = true | ||
| 471 | |||
| 472 | |||
| 473 | func send_location(loc_id): | ||
| 474 | if _batch_locations: | ||
| 475 | _held_locations.append(loc_id) | ||
| 476 | else: | ||
| 477 | client.sendLocation(loc_id) | ||
| 478 | |||
| 479 | |||
| 480 | func scout_location(loc_id): | ||
| 481 | if _location_scouts.has(loc_id): | ||
| 482 | return _location_scouts.get(loc_id) | ||
| 483 | |||
| 484 | if _batch_locations: | ||
| 485 | _held_location_scouts.append(loc_id) | ||
| 486 | else: | ||
| 487 | client.scoutLocation(loc_id) | ||
| 488 | |||
| 489 | return null | ||
| 490 | |||
| 491 | |||
| 492 | func stop_batching_locations(): | ||
| 493 | _batch_locations = false | ||
| 494 | |||
| 495 | if not _held_locations.is_empty(): | ||
| 496 | client.sendLocations(_held_locations) | ||
| 497 | _held_locations.clear() | ||
| 498 | |||
| 499 | if not _held_location_scouts.is_empty(): | ||
| 500 | client.scoutLocations(_held_location_scouts) | ||
| 501 | _held_location_scouts.clear() | ||
| 502 | |||
| 503 | |||
| 504 | func colorForItemType(flags): | ||
| 505 | var int_flags = int(flags) | ||
| 506 | if int_flags & 1: # progression | ||
| 507 | if int_flags & 2: # proguseful | ||
| 508 | return "#f0d200" | ||
| 509 | else: | ||
| 510 | return "#bc51e0" | ||
| 511 | elif int_flags & 2: # useful | ||
| 512 | return "#2b67ff" | ||
| 513 | elif int_flags & 4: # trap | ||
| 514 | return "#d63a22" | ||
| 515 | else: # filler | ||
| 516 | return "#14de9e" | ||
| 517 | |||
| 518 | |||
| 519 | func wrapInItemColorTags(text, flags): | ||
| 520 | var int_flags = int(flags) | ||
| 521 | if int_flags & 1 and int_flags & 2: # proguseful | ||
| 522 | return "[rainbow]%s[/rainbow]" % text | ||
| 523 | else: | ||
| 524 | return "[color=%s]%s[/color]" % [colorForItemType(flags), text] | ||
| 525 | |||
| 526 | |||
| 527 | func get_letter_behavior(key, level2): | ||
| 528 | if shuffle_letters == kSHUFFLE_LETTERS_UNLOCKED: | ||
| 529 | return kLETTER_BEHAVIOR_UNLOCKED | ||
| 530 | |||
| 531 | if [kSHUFFLE_LETTERS_VANILLA_CYAN, kSHUFFLE_LETTERS_ITEM_CYAN].has(shuffle_letters): | ||
| 532 | if level2: | ||
| 533 | if shuffle_letters == kSHUFFLE_LETTERS_VANILLA_CYAN: | ||
| 534 | return kLETTER_BEHAVIOR_VANILLA | ||
| 535 | else: | ||
| 536 | return kLETTER_BEHAVIOR_ITEM | ||
| 537 | else: | ||
| 538 | return kLETTER_BEHAVIOR_UNLOCKED | ||
| 539 | |||
| 540 | if not level2 and ["h", "i", "n", "t"].has(key): | ||
| 541 | # This differs from the equivalent function in the apworld. Logically it is | ||
| 542 | # the same as UNLOCKED since they are in the starting room, but VANILLA | ||
| 543 | # means the player still has to actually pick up the letters. | ||
| 544 | return kLETTER_BEHAVIOR_VANILLA | ||
| 545 | |||
| 546 | if shuffle_letters == kSHUFFLE_LETTERS_PROGRESSIVE: | ||
| 547 | return kLETTER_BEHAVIOR_ITEM | ||
| 548 | |||
| 549 | return kLETTER_BEHAVIOR_VANILLA | ||
| 550 | |||
| 551 | |||
| 552 | func setup_keys(): | ||
| 553 | keyboard.load_seed() | ||
| 554 | |||
| 555 | _letters_setup = true | ||
| 556 | |||
| 557 | for k in _held_letters.keys(): | ||
| 558 | _process_key_item(k, _held_letters[k]) | ||
| 559 | |||
| 560 | _held_letters.clear() | ||
| 561 | |||
| 562 | |||
| 563 | func _process_key_item(key, level): | ||
| 564 | if not _letters_setup: | ||
| 565 | _held_letters[key] = max(_held_letters.get(key, 0), level) | ||
| 566 | return | ||
| 567 | |||
| 568 | if shuffle_letters == kSHUFFLE_LETTERS_ITEM_CYAN: | ||
| 569 | level += 1 | ||
| 570 | |||
| 571 | keyboard.collect_remote_letter(key, level) | ||
| diff --git a/client/Archipelago/messages.gd b/client/Archipelago/messages.gd deleted file mode 100644 index ab4f071..0000000 --- a/client/Archipelago/messages.gd +++ /dev/null | |||
| @@ -1,74 +0,0 @@ | |||
| 1 | extends CanvasLayer | ||
| 2 | |||
| 3 | var SCRIPT_rainbowText | ||
| 4 | |||
| 5 | var _message_queue = [] | ||
| 6 | var _font | ||
| 7 | var _container | ||
| 8 | var _ordered_labels = [] | ||
| 9 | |||
| 10 | |||
| 11 | func _ready(): | ||
| 12 | _container = VBoxContainer.new() | ||
| 13 | _container.set_name("Container") | ||
| 14 | _container.anchor_bottom = 1 | ||
| 15 | _container.offset_left = 20.0 | ||
| 16 | _container.offset_right = 1920.0 | ||
| 17 | _container.offset_top = 0.0 | ||
| 18 | _container.offset_bottom = -20.0 | ||
| 19 | _container.alignment = BoxContainer.ALIGNMENT_END | ||
| 20 | _container.mouse_filter = Control.MOUSE_FILTER_IGNORE | ||
| 21 | self.add_child(_container) | ||
| 22 | |||
| 23 | _font = load("res://assets/fonts/Lingo2.ttf") | ||
| 24 | |||
| 25 | |||
| 26 | func _add_message(text): | ||
| 27 | var new_label = RichTextLabel.new() | ||
| 28 | new_label.install_effect(SCRIPT_rainbowText.new()) | ||
| 29 | new_label.push_font(_font) | ||
| 30 | new_label.push_font_size(36) | ||
| 31 | new_label.push_outline_color(Color(0, 0, 0, 1)) | ||
| 32 | new_label.push_outline_size(2) | ||
| 33 | new_label.append_text(text) | ||
| 34 | new_label.fit_content = true | ||
| 35 | |||
| 36 | _container.add_child(new_label) | ||
| 37 | _ordered_labels.push_back(new_label) | ||
| 38 | |||
| 39 | |||
| 40 | func showMessage(text): | ||
| 41 | if _ordered_labels.size() >= 9: | ||
| 42 | _message_queue.append(text) | ||
| 43 | return | ||
| 44 | |||
| 45 | _add_message(text) | ||
| 46 | |||
| 47 | if _ordered_labels.size() > 1: | ||
| 48 | return | ||
| 49 | |||
| 50 | var timeout = 10.0 | ||
| 51 | while !_ordered_labels.is_empty(): | ||
| 52 | await get_tree().create_timer(timeout).timeout | ||
| 53 | |||
| 54 | if !_ordered_labels.is_empty(): | ||
| 55 | var to_remove = _ordered_labels.pop_front() | ||
| 56 | var to_tween = get_tree().create_tween().bind_node(to_remove) | ||
| 57 | to_tween.tween_property(to_remove, "modulate:a", 0.0, 0.5) | ||
| 58 | to_tween.tween_callback(to_remove.queue_free) | ||
| 59 | |||
| 60 | if !_message_queue.is_empty(): | ||
| 61 | var next_msg = _message_queue.pop_front() | ||
| 62 | _add_message(next_msg) | ||
| 63 | |||
| 64 | if timeout > 4: | ||
| 65 | timeout -= 3 | ||
| 66 | |||
| 67 | |||
| 68 | func clear(): | ||
| 69 | _message_queue.clear() | ||
| 70 | |||
| 71 | for message_label in _ordered_labels: | ||
| 72 | message_label.queue_free() | ||
| 73 | |||
| 74 | _ordered_labels.clear() | ||
| diff --git a/client/Archipelago/minimap.gd b/client/Archipelago/minimap.gd deleted file mode 100644 index 5640716..0000000 --- a/client/Archipelago/minimap.gd +++ /dev/null | |||
| @@ -1,175 +0,0 @@ | |||
| 1 | extends CanvasLayer | ||
| 2 | |||
| 3 | var player | ||
| 4 | var drawer | ||
| 5 | var sprite | ||
| 6 | var label | ||
| 7 | |||
| 8 | var cell_left | ||
| 9 | var cell_top | ||
| 10 | var cell_right | ||
| 11 | var cell_bottom | ||
| 12 | var cell_width | ||
| 13 | var cell_height | ||
| 14 | var center_x_min | ||
| 15 | var center_x_max | ||
| 16 | var center_y_min | ||
| 17 | var center_y_max | ||
| 18 | |||
| 19 | |||
| 20 | func _ready(): | ||
| 21 | player = get_tree().get_root().get_node("scene/player") | ||
| 22 | |||
| 23 | var svc = PanelContainer.new() | ||
| 24 | svc.anchor_left = 1.0 | ||
| 25 | svc.anchor_top = 1.0 | ||
| 26 | svc.anchor_right = 1.0 | ||
| 27 | svc.anchor_bottom = 1.0 | ||
| 28 | svc.offset_left = -320.0 | ||
| 29 | svc.offset_top = -320.0 | ||
| 30 | svc.offset_right = -64.0 | ||
| 31 | svc.offset_bottom = -64.0 | ||
| 32 | svc.clip_contents = true | ||
| 33 | add_child(svc) | ||
| 34 | |||
| 35 | var background_color = Color.WHITE | ||
| 36 | |||
| 37 | var world_env = get_tree().get_root().get_node("scene/WorldEnvironment") | ||
| 38 | if world_env != null and world_env.environment != null: | ||
| 39 | if world_env.environment.background_mode == Environment.BG_COLOR: | ||
| 40 | background_color = world_env.environment.background_color | ||
| 41 | elif ( | ||
| 42 | world_env.environment.background_mode == Environment.BG_SKY | ||
| 43 | and world_env.environment.sky != null | ||
| 44 | and world_env.environment.sky.sky_material != null | ||
| 45 | ): | ||
| 46 | var sky = world_env.environment.sky.sky_material | ||
| 47 | if sky is PhysicalSkyMaterial: | ||
| 48 | background_color = sky.ground_color | ||
| 49 | elif sky is ProceduralSkyMaterial: | ||
| 50 | background_color = sky.sky_top_color | ||
| 51 | |||
| 52 | var stylebox = StyleBoxFlat.new() | ||
| 53 | stylebox.bg_color = Color(background_color, 0.6) | ||
| 54 | svc.add_theme_stylebox_override("panel", stylebox) | ||
| 55 | |||
| 56 | drawer = Node2D.new() | ||
| 57 | svc.add_child(drawer) | ||
| 58 | |||
| 59 | var gridmap = get_tree().get_root().get_node("scene/GridMap") | ||
| 60 | if gridmap == null: | ||
| 61 | visible = false | ||
| 62 | return | ||
| 63 | |||
| 64 | cell_left = 0 | ||
| 65 | cell_top = 0 | ||
| 66 | cell_right = 0 | ||
| 67 | cell_bottom = 0 | ||
| 68 | |||
| 69 | for pos in gridmap.get_used_cells(): | ||
| 70 | if pos.x < cell_left: | ||
| 71 | cell_left = pos.x | ||
| 72 | if pos.x > cell_right: | ||
| 73 | cell_right = pos.x | ||
| 74 | if pos.z < cell_top: | ||
| 75 | cell_top = pos.z | ||
| 76 | if pos.z > cell_bottom: | ||
| 77 | cell_bottom = pos.z | ||
| 78 | |||
| 79 | cell_width = cell_right - cell_left + 1 | ||
| 80 | cell_height = cell_bottom - cell_top + 1 | ||
| 81 | |||
| 82 | var rendered = _renderMap(gridmap) | ||
| 83 | |||
| 84 | var image_texture = ImageTexture.create_from_image(rendered) | ||
| 85 | sprite = Sprite2D.new() | ||
| 86 | sprite.texture = image_texture | ||
| 87 | sprite.texture_filter = CanvasItem.TEXTURE_FILTER_NEAREST | ||
| 88 | sprite.scale = Vector2(2, 2) | ||
| 89 | sprite.centered = false | ||
| 90 | drawer.add_child(sprite) | ||
| 91 | |||
| 92 | label = Label.new() | ||
| 93 | label.theme = preload("res://assets/themes/baseUI.tres") | ||
| 94 | label.add_theme_font_size_override("font_size", 32) | ||
| 95 | label.text = "@" | ||
| 96 | drawer.add_child(label) | ||
| 97 | |||
| 98 | #var local_tl = gridmap.map_to_local(Vector3i(cell_left, 0, cell_top)) | ||
| 99 | #var global_tl = gridmap.to_global(local_tl) | ||
| 100 | #var local_br = gridmap.map_to_local(Vector3i(cell_right, 0, cell_bottom)) | ||
| 101 | #var global_br = gridmap.to_global(local_br) | ||
| 102 | |||
| 103 | center_x_min = 0 | ||
| 104 | center_x_max = cell_width - 128 | ||
| 105 | center_y_min = 0 | ||
| 106 | center_y_max = cell_height - 128 | ||
| 107 | |||
| 108 | if center_x_max < center_x_min: | ||
| 109 | center_x_min = (center_x_min + center_x_max) / 2 | ||
| 110 | center_x_max = center_x_min | ||
| 111 | |||
| 112 | if center_y_max < center_y_min: | ||
| 113 | center_y_min = (center_y_min + center_y_max) / 2 | ||
| 114 | center_y_max = center_y_min | ||
| 115 | |||
| 116 | |||
| 117 | func _process(_delta): | ||
| 118 | if visible == false: | ||
| 119 | return | ||
| 120 | |||
| 121 | drawer.position.x = clamp(player.position.x - cell_left - 64, center_x_min, center_x_max) * -2 | ||
| 122 | drawer.position.y = clamp(player.position.z - cell_top - 64, center_y_min, center_y_max) * -2 | ||
| 123 | |||
| 124 | label.position.x = (player.position.x - cell_left) * 2 - 16 | ||
| 125 | label.position.y = (player.position.z - cell_top) * 2 - 16 | ||
| 126 | |||
| 127 | |||
| 128 | func _renderMap(gridmap): | ||
| 129 | var heights = {} | ||
| 130 | |||
| 131 | var rendered = Image.create_empty(cell_width, cell_height, false, Image.FORMAT_RGBA8) | ||
| 132 | rendered.fill(Color.TRANSPARENT) | ||
| 133 | |||
| 134 | var meshes_node = get_tree().get_root().get_node("scene/Meshes") | ||
| 135 | if meshes_node != null: | ||
| 136 | _renderMeshNode(gridmap, meshes_node, rendered) | ||
| 137 | |||
| 138 | for pos in gridmap.get_used_cells(): | ||
| 139 | var in_plane = Vector2i(pos.x, pos.z) | ||
| 140 | |||
| 141 | if in_plane in heights and heights[in_plane] > pos.y: | ||
| 142 | continue | ||
| 143 | |||
| 144 | heights[in_plane] = pos.y | ||
| 145 | |||
| 146 | var cell_item = gridmap.get_cell_item(pos) | ||
| 147 | var mesh = gridmap.mesh_library.get_item_mesh(cell_item) | ||
| 148 | var material = mesh.surface_get_material(0) | ||
| 149 | var color = material.albedo_color | ||
| 150 | |||
| 151 | rendered.set_pixel(pos.x - cell_left, pos.z - cell_top, color) | ||
| 152 | |||
| 153 | return rendered | ||
| 154 | |||
| 155 | |||
| 156 | func _renderMeshNode(gridmap, mesh, rendered): | ||
| 157 | if mesh is MeshInstance3D: | ||
| 158 | var local_tl = gridmap.map_to_local(Vector3i(cell_left, 0, cell_top)) | ||
| 159 | var global_tl = gridmap.to_global(local_tl) | ||
| 160 | var mesh_material = mesh.get_surface_override_material(0) | ||
| 161 | if mesh_material != null: | ||
| 162 | var mesh_color = mesh_material.albedo_color | ||
| 163 | |||
| 164 | for y in range( | ||
| 165 | max(mesh.position.z - mesh.scale.z / 2 - global_tl.z, 0), | ||
| 166 | min(mesh.position.z + mesh.scale.z / 2 - global_tl.z, cell_height) | ||
| 167 | ): | ||
| 168 | for x in range( | ||
| 169 | max(mesh.position.x - mesh.scale.x / 2 - global_tl.x, 0), | ||
| 170 | min(mesh.position.x + mesh.scale.x / 2 - global_tl.x, cell_width) | ||
| 171 | ): | ||
| 172 | rendered.set_pixel(x, y, mesh_color) | ||
| 173 | |||
| 174 | for child in mesh.get_children(): | ||
| 175 | _renderMeshNode(gridmap, child, rendered) | ||
| diff --git a/client/Archipelago/painting.gd b/client/Archipelago/painting.gd deleted file mode 100644 index 276d4eb..0000000 --- a/client/Archipelago/painting.gd +++ /dev/null | |||
| @@ -1,38 +0,0 @@ | |||
| 1 | extends "res://scripts/nodes/painting.gd" | ||
| 2 | |||
| 3 | var item_id | ||
| 4 | var item_amount | ||
| 5 | |||
| 6 | |||
| 7 | func _ready(): | ||
| 8 | var node_path = String( | ||
| 9 | get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names() | ||
| 10 | ) | ||
| 11 | |||
| 12 | var gamedata = global.get_node("Gamedata") | ||
| 13 | var door_id = gamedata.get_door_for_map_node_path(global.map, node_path) | ||
| 14 | if door_id != null: | ||
| 15 | var ap = global.get_node("Archipelago") | ||
| 16 | var item_lock = ap.get_item_id_for_door(door_id) | ||
| 17 | |||
| 18 | if item_lock != null: | ||
| 19 | item_id = item_lock[0] | ||
| 20 | item_amount = item_lock[1] | ||
| 21 | |||
| 22 | self.senders = [] | ||
| 23 | self.senderGroup = [] | ||
| 24 | self.nested = false | ||
| 25 | self.complete_at = 0 | ||
| 26 | self.max_length = 0 | ||
| 27 | self.excludeSenders = [] | ||
| 28 | |||
| 29 | call_deferred("_readier") | ||
| 30 | |||
| 31 | super._ready() | ||
| 32 | |||
| 33 | |||
| 34 | func _readier(): | ||
| 35 | var ap = global.get_node("Archipelago") | ||
| 36 | |||
| 37 | if ap.client.getItemAmount(item_id) >= item_amount: | ||
| 38 | handleTriggered() | ||
| diff --git a/client/Archipelago/panel.gd b/client/Archipelago/panel.gd deleted file mode 100644 index fdaaf0e..0000000 --- a/client/Archipelago/panel.gd +++ /dev/null | |||
| @@ -1,101 +0,0 @@ | |||
| 1 | extends "res://scripts/nodes/panel.gd" | ||
| 2 | |||
| 3 | var panel_logic = null | ||
| 4 | var symbol_solvable = true | ||
| 5 | |||
| 6 | var black = load("res://assets/materials/black.material") | ||
| 7 | |||
| 8 | |||
| 9 | func _ready(): | ||
| 10 | super._ready() | ||
| 11 | |||
| 12 | var node_path = String( | ||
| 13 | get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names() | ||
| 14 | ) | ||
| 15 | |||
| 16 | var gamedata = global.get_node("Gamedata") | ||
| 17 | var panel_id = gamedata.get_panel_for_map_node_path(global.map, node_path) | ||
| 18 | if panel_id != null: | ||
| 19 | var ap = global.get_node("Archipelago") | ||
| 20 | if ap.shuffle_symbols: | ||
| 21 | if global.map == "the_entry" and node_path == "Panels/Entry/front_1": | ||
| 22 | clue = "i" | ||
| 23 | symbol = "" | ||
| 24 | |||
| 25 | setField("clue", clue) | ||
| 26 | setField("symbol", symbol) | ||
| 27 | |||
| 28 | panel_logic = gamedata.objects.get_panels()[panel_id] | ||
| 29 | checkSymbolSolvable() | ||
| 30 | |||
| 31 | if not symbol_solvable: | ||
| 32 | get_tree().get_root().get_node("scene/player").connect( | ||
| 33 | "evaluate_solvability", evaluateSolvability | ||
| 34 | ) | ||
| 35 | |||
| 36 | |||
| 37 | func checkSymbolSolvable(): | ||
| 38 | var old_solvable = symbol_solvable | ||
| 39 | symbol_solvable = true | ||
| 40 | |||
| 41 | if panel_logic == null: | ||
| 42 | # There's no logic for this panel. | ||
| 43 | return | ||
| 44 | |||
| 45 | var ap = global.get_node("Archipelago") | ||
| 46 | if not ap.shuffle_symbols: | ||
| 47 | # Symbols aren't item-locked. | ||
| 48 | return | ||
| 49 | |||
| 50 | var gamedata = global.get_node("Gamedata") | ||
| 51 | for symbol in panel_logic.get_symbols(): | ||
| 52 | var item_name = gamedata.kSYMBOL_ITEMS.get(symbol) | ||
| 53 | var item_id = gamedata.objects.get_special_ids()[item_name] | ||
| 54 | if ap.client.getItemAmount(item_id) < 1: | ||
| 55 | symbol_solvable = false | ||
| 56 | break | ||
| 57 | |||
| 58 | if symbol_solvable != old_solvable: | ||
| 59 | if symbol_solvable: | ||
| 60 | setField("clue", clue) | ||
| 61 | setField("symbol", symbol) | ||
| 62 | setField("answer", answer) | ||
| 63 | else: | ||
| 64 | quad_mesh.surface_set_material(0, black) | ||
| 65 | get_node("Hinge/clue").text = "missing" | ||
| 66 | get_node("Hinge/answer").text = "symbols" | ||
| 67 | |||
| 68 | |||
| 69 | func checkSolvable(key): | ||
| 70 | checkSymbolSolvable() | ||
| 71 | if not symbol_solvable: | ||
| 72 | return false | ||
| 73 | |||
| 74 | return super.checkSolvable(key) | ||
| 75 | |||
| 76 | |||
| 77 | func evaluateSolvability(): | ||
| 78 | checkSolvable("") | ||
| 79 | |||
| 80 | |||
| 81 | func passedInput(key, skip_focus_check = false): | ||
| 82 | if not symbol_solvable: | ||
| 83 | return | ||
| 84 | |||
| 85 | super.passedInput(key, skip_focus_check) | ||
| 86 | |||
| 87 | |||
| 88 | func focus(): | ||
| 89 | if not symbol_solvable: | ||
| 90 | has_focus = false | ||
| 91 | return | ||
| 92 | |||
| 93 | super.focus() | ||
| 94 | |||
| 95 | |||
| 96 | func unfocus(): | ||
| 97 | if not symbol_solvable: | ||
| 98 | has_focus = false | ||
| 99 | return | ||
| 100 | |||
| 101 | super.unfocus() | ||
| diff --git a/client/Archipelago/pauseMenu.gd b/client/Archipelago/pauseMenu.gd deleted file mode 100644 index cd1813c..0000000 --- a/client/Archipelago/pauseMenu.gd +++ /dev/null | |||
| @@ -1,44 +0,0 @@ | |||
| 1 | extends "res://scripts/ui/pauseMenu.gd" | ||
| 2 | |||
| 3 | var compass_button | ||
| 4 | |||
| 5 | |||
| 6 | func _ready(): | ||
| 7 | var ap_panel = Panel.new() | ||
| 8 | ap_panel.name = "Archipelago" | ||
| 9 | get_node("menu/settings/settingsInner/TabContainer").add_child(ap_panel) | ||
| 10 | |||
| 11 | var ap = global.get_node("Archipelago") | ||
| 12 | |||
| 13 | compass_button = CheckBox.new() | ||
| 14 | compass_button.text = "show compass" | ||
| 15 | compass_button.button_pressed = ap.show_compass | ||
| 16 | compass_button.position = Vector2(65, 100) | ||
| 17 | compass_button.theme = preload("res://assets/themes/baseUI.tres") | ||
| 18 | compass_button.add_theme_font_size_override("font_size", 60) | ||
| 19 | compass_button.pressed.connect(_toggle_compass) | ||
| 20 | ap_panel.add_child(compass_button) | ||
| 21 | |||
| 22 | super._ready() | ||
| 23 | |||
| 24 | |||
| 25 | func _pause_game(): | ||
| 26 | global.get_node("Textclient").dismiss() | ||
| 27 | super._pause_game() | ||
| 28 | |||
| 29 | |||
| 30 | func _main_menu(): | ||
| 31 | global.loaded = false | ||
| 32 | global.get_node("Archipelago").disconnect_from_ap() | ||
| 33 | global.get_node("Messages").clear() | ||
| 34 | global.get_node("Compass").visible = false | ||
| 35 | super._main_menu() | ||
| 36 | |||
| 37 | |||
| 38 | func _toggle_compass(): | ||
| 39 | var ap = global.get_node("Archipelago") | ||
| 40 | ap.show_compass = compass_button.button_pressed | ||
| 41 | ap.saveSettings() | ||
| 42 | |||
| 43 | var compass = global.get_node("Compass") | ||
| 44 | compass.visible = compass_button.button_pressed | ||
| diff --git a/client/Archipelago/player.gd b/client/Archipelago/player.gd deleted file mode 100644 index e58f1bc..0000000 --- a/client/Archipelago/player.gd +++ /dev/null | |||
| @@ -1,369 +0,0 @@ | |||
| 1 | extends "res://scripts/nodes/player.gd" | ||
| 2 | |||
| 3 | const kEndingNameByVictoryValue = { | ||
| 4 | 0: "GRAY", | ||
| 5 | 1: "PURPLE", | ||
| 6 | 2: "MINT", | ||
| 7 | 3: "BLACK", | ||
| 8 | 4: "BLUE", | ||
| 9 | 5: "CYAN", | ||
| 10 | 6: "RED", | ||
| 11 | 7: "PLUM", | ||
| 12 | 8: "ORANGE", | ||
| 13 | 9: "GOLD", | ||
| 14 | 10: "YELLOW", | ||
| 15 | 11: "GREEN", | ||
| 16 | 12: "WHITE", | ||
| 17 | } | ||
| 18 | |||
| 19 | signal evaluate_solvability | ||
| 20 | |||
| 21 | var compass | ||
| 22 | |||
| 23 | |||
| 24 | func _ready(): | ||
| 25 | var khl_script = load("res://scripts/nodes/keyHolderListener.gd") | ||
| 26 | |||
| 27 | var pause_menu = get_node("pause_menu") | ||
| 28 | pause_menu.layer = 3 | ||
| 29 | |||
| 30 | var ap = global.get_node("Archipelago") | ||
| 31 | var gamedata = global.get_node("Gamedata") | ||
| 32 | |||
| 33 | compass = global.get_node("Compass") | ||
| 34 | compass.visible = ap.show_compass | ||
| 35 | |||
| 36 | ap.start_batching_locations() | ||
| 37 | |||
| 38 | # Set up door locations. | ||
| 39 | var map_id = gamedata.map_id_by_name.get(global.map) | ||
| 40 | for door in gamedata.objects.get_doors(): | ||
| 41 | if door.get_map_id() != map_id: | ||
| 42 | continue | ||
| 43 | |||
| 44 | if not door.has_ap_id(): | ||
| 45 | continue | ||
| 46 | |||
| 47 | if ( | ||
| 48 | door.get_type() == gamedata.SCRIPT_proto.DoorType.ITEM_ONLY | ||
| 49 | or door.get_type() == gamedata.SCRIPT_proto.DoorType.GALLERY_PAINTING | ||
| 50 | ): | ||
| 51 | continue | ||
| 52 | |||
| 53 | var locationListener = ap.SCRIPT_locationListener.new() | ||
| 54 | locationListener.location_id = door.get_ap_id() | ||
| 55 | locationListener.name = "locationListener_%d" % door.get_ap_id() | ||
| 56 | |||
| 57 | for panel_ref in door.get_panels(): | ||
| 58 | var panel_data = gamedata.objects.get_panels()[panel_ref.get_panel()] | ||
| 59 | var panel_path = panel_data.get_path() | ||
| 60 | |||
| 61 | if panel_ref.has_answer(): | ||
| 62 | for proxy in panel_data.get_proxies(): | ||
| 63 | if proxy.get_answer() == panel_ref.get_answer(): | ||
| 64 | panel_path = proxy.get_path() | ||
| 65 | break | ||
| 66 | |||
| 67 | locationListener.senders.append(NodePath("/root/scene/" + panel_path)) | ||
| 68 | |||
| 69 | for keyholder_ref in door.get_keyholders(): | ||
| 70 | var keyholder_data = gamedata.objects.get_keyholders()[keyholder_ref.get_keyholder()] | ||
| 71 | |||
| 72 | var khl = khl_script.new() | ||
| 73 | khl.name = ( | ||
| 74 | "location_%d_keyholder_%d" % [door.get_ap_id(), keyholder_ref.get_keyholder()] | ||
| 75 | ) | ||
| 76 | khl.answer = keyholder_ref.get_key() | ||
| 77 | khl.senders.append(NodePath("/root/scene/" + keyholder_data.get_path())) | ||
| 78 | get_parent().add_child.call_deferred(khl) | ||
| 79 | |||
| 80 | locationListener.senders.append(NodePath("../" + khl.name)) | ||
| 81 | |||
| 82 | for sender in door.get_senders(): | ||
| 83 | locationListener.senders.append(NodePath("/root/scene/" + sender)) | ||
| 84 | |||
| 85 | if door.has_complete_at(): | ||
| 86 | locationListener.complete_at = door.get_complete_at() | ||
| 87 | |||
| 88 | get_parent().add_child.call_deferred(locationListener) | ||
| 89 | |||
| 90 | # Set up letter locations. | ||
| 91 | for letter in gamedata.objects.get_letters(): | ||
| 92 | var room = gamedata.objects.get_rooms()[letter.get_room_id()] | ||
| 93 | if room.get_map_id() != map_id: | ||
| 94 | continue | ||
| 95 | |||
| 96 | var locationListener = ap.SCRIPT_locationListener.new() | ||
| 97 | locationListener.location_id = letter.get_ap_id() | ||
| 98 | locationListener.name = "locationListener_%d" % letter.get_ap_id() | ||
| 99 | locationListener.senders.append(NodePath("/root/scene/" + letter.get_path())) | ||
| 100 | |||
| 101 | get_parent().add_child.call_deferred(locationListener) | ||
| 102 | |||
| 103 | if ( | ||
| 104 | ap.get_letter_behavior(letter.get_key(), letter.has_level2() and letter.get_level2()) | ||
| 105 | != ap.kLETTER_BEHAVIOR_VANILLA | ||
| 106 | ): | ||
| 107 | var scout = ap.scout_location(letter.get_ap_id()) | ||
| 108 | if ( | ||
| 109 | scout != null | ||
| 110 | and not (scout["player"] == ap.client._slot and scout["flags"] & 4 != 0) | ||
| 111 | ): | ||
| 112 | var item_name = "Unknown" | ||
| 113 | var item_player_game = ap.client._game_by_player[float(scout["player"])] | ||
| 114 | if ap.client._item_id_to_name[item_player_game].has(scout["item"]): | ||
| 115 | item_name = ap.client._item_id_to_name[item_player_game][scout["item"]] | ||
| 116 | |||
| 117 | var collectable = get_tree().get_root().get_node("scene").get_node_or_null( | ||
| 118 | letter.get_path() | ||
| 119 | ) | ||
| 120 | if collectable != null: | ||
| 121 | collectable.setScoutedText.call_deferred(item_name) | ||
| 122 | |||
| 123 | # Set up mastery locations. | ||
| 124 | for mastery in gamedata.objects.get_masteries(): | ||
| 125 | var room = gamedata.objects.get_rooms()[mastery.get_room_id()] | ||
| 126 | if room.get_map_id() != map_id: | ||
| 127 | continue | ||
| 128 | |||
| 129 | var locationListener = ap.SCRIPT_locationListener.new() | ||
| 130 | locationListener.location_id = mastery.get_ap_id() | ||
| 131 | locationListener.name = "locationListener_%d" % mastery.get_ap_id() | ||
| 132 | locationListener.senders.append(NodePath("/root/scene/" + mastery.get_path())) | ||
| 133 | |||
| 134 | get_parent().add_child.call_deferred(locationListener) | ||
| 135 | |||
| 136 | # Set up ending locations. | ||
| 137 | for ending in gamedata.objects.get_endings(): | ||
| 138 | var room = gamedata.objects.get_rooms()[ending.get_room_id()] | ||
| 139 | if room.get_map_id() != map_id: | ||
| 140 | continue | ||
| 141 | |||
| 142 | var locationListener = ap.SCRIPT_locationListener.new() | ||
| 143 | locationListener.location_id = ending.get_ap_id() | ||
| 144 | locationListener.name = "locationListener_%d" % ending.get_ap_id() | ||
| 145 | locationListener.senders.append(NodePath("/root/scene/" + ending.get_path())) | ||
| 146 | |||
| 147 | get_parent().add_child.call_deferred(locationListener) | ||
| 148 | |||
| 149 | if kEndingNameByVictoryValue.get(ap.victory_condition, null) == ending.get_name(): | ||
| 150 | var victoryListener = ap.SCRIPT_victoryListener.new() | ||
| 151 | victoryListener.name = "victoryListener" | ||
| 152 | victoryListener.senders.append(NodePath("/root/scene/" + ending.get_path())) | ||
| 153 | |||
| 154 | get_parent().add_child.call_deferred(victoryListener) | ||
| 155 | |||
| 156 | # Set up keyholder locations, in keyholder sanity. | ||
| 157 | if ap.keyholder_sanity: | ||
| 158 | for keyholder in gamedata.objects.get_keyholders(): | ||
| 159 | if not keyholder.has_key(): | ||
| 160 | continue | ||
| 161 | |||
| 162 | var room = gamedata.objects.get_rooms()[keyholder.get_room_id()] | ||
| 163 | if room.get_map_id() != map_id: | ||
| 164 | continue | ||
| 165 | |||
| 166 | var locationListener = ap.SCRIPT_locationListener.new() | ||
| 167 | locationListener.location_id = keyholder.get_ap_id() | ||
| 168 | locationListener.name = "locationListener_%d" % keyholder.get_ap_id() | ||
| 169 | |||
| 170 | var khl = khl_script.new() | ||
| 171 | khl.name = "location_%d_keyholder" % keyholder.get_ap_id() | ||
| 172 | khl.answer = keyholder.get_key() | ||
| 173 | khl.senders.append(NodePath("/root/scene/" + keyholder.get_path())) | ||
| 174 | get_parent().add_child.call_deferred(khl) | ||
| 175 | |||
| 176 | locationListener.senders.append(NodePath("../" + khl.name)) | ||
| 177 | |||
| 178 | get_parent().add_child.call_deferred(locationListener) | ||
| 179 | |||
| 180 | # Block off roof access in Daedalus. | ||
| 181 | if global.map == "daedalus" and not ap.daedalus_roof_access: | ||
| 182 | _set_up_invis_wall(75.5, 11, -24.5, 1, 10, 49) | ||
| 183 | _set_up_invis_wall(51.5, 11, -17, 16, 10, 1) | ||
| 184 | _set_up_invis_wall(46, 10, -9.5, 1, 10, 10) | ||
| 185 | _set_up_invis_wall(67.5, 11, 17, 16, 10, 1) | ||
| 186 | _set_up_invis_wall(50.5, 11, 14, 10, 10, 1) | ||
| 187 | _set_up_invis_wall(39, 10, 18.5, 1, 10, 22) | ||
| 188 | _set_up_invis_wall(20, 15, 18.5, 1, 10, 16) | ||
| 189 | _set_up_invis_wall(11.5, 15, 3, 32, 10, 1) | ||
| 190 | _set_up_invis_wall(11.5, 16, -20, 14, 20, 1) | ||
| 191 | _set_up_invis_wall(14, 16, -26.5, 1, 20, 4) | ||
| 192 | _set_up_invis_wall(28.5, 20.5, -26.5, 1, 15, 25) | ||
| 193 | _set_up_invis_wall(40.5, 20.5, -11, 30, 15, 1) | ||
| 194 | _set_up_invis_wall(50.5, 15, 5.5, 7, 10, 1) | ||
| 195 | _set_up_invis_wall(83.5, 33.5, 5.5, 1, 7, 11) | ||
| 196 | _set_up_invis_wall(83.5, 33.5, -5.5, 1, 7, 11) | ||
| 197 | |||
| 198 | var warp_exit_prefab = preload("res://objects/nodes/exit.tscn") | ||
| 199 | var warp_exit = warp_exit_prefab.instantiate() | ||
| 200 | warp_exit.name = "roof_access_blocker_warp_exit" | ||
| 201 | warp_exit.position = Vector3(58, 10, 0) | ||
| 202 | warp_exit.rotation_degrees.y = 90 | ||
| 203 | get_parent().add_child.call_deferred(warp_exit) | ||
| 204 | |||
| 205 | var warp_enter_prefab = preload("res://objects/nodes/teleportAuto.tscn") | ||
| 206 | var warp_enter = warp_enter_prefab.instantiate() | ||
| 207 | warp_enter.target = warp_exit | ||
| 208 | warp_enter.position = Vector3(76.5, 30, 1) | ||
| 209 | warp_enter.scale = Vector3(4, 1.5, 1) | ||
| 210 | warp_enter.rotation_degrees.y = 90 | ||
| 211 | get_parent().add_child.call_deferred(warp_enter) | ||
| 212 | |||
| 213 | if global.map == "the_entry": | ||
| 214 | # Remove door behind X1. | ||
| 215 | var door_node = get_tree().get_root().get_node("/root/scene/Components/Doors/exit_1") | ||
| 216 | door_node.handleTriggered() | ||
| 217 | |||
| 218 | # Display win condition. | ||
| 219 | var sign_prefab = preload("res://objects/nodes/sign.tscn") | ||
| 220 | var sign1 = sign_prefab.instantiate() | ||
| 221 | sign1.position = Vector3(-7, 5, -15.01) | ||
| 222 | sign1.text = "victory" | ||
| 223 | get_parent().add_child.call_deferred(sign1) | ||
| 224 | |||
| 225 | var sign2 = sign_prefab.instantiate() | ||
| 226 | sign2.position = Vector3(-7, 4, -15.01) | ||
| 227 | sign2.text = "%s ending" % kEndingNameByVictoryValue.get(ap.victory_condition, "?") | ||
| 228 | |||
| 229 | var sign2_color = kEndingNameByVictoryValue.get(ap.victory_condition, "coral").to_lower() | ||
| 230 | if sign2_color == "white": | ||
| 231 | sign2_color = "silver" | ||
| 232 | |||
| 233 | sign2.material = load("res://assets/materials/%s.material" % sign2_color) | ||
| 234 | get_parent().add_child.call_deferred(sign2) | ||
| 235 | |||
| 236 | # Add the strict purple ending validation. | ||
| 237 | if global.map == "the_sun_temple" and ap.strict_purple_ending: | ||
| 238 | var panel_prefab = preload("res://objects/nodes/panel.tscn") | ||
| 239 | var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn") | ||
| 240 | var reverse_prefab = preload("res://objects/nodes/listeners/reversingListener.tscn") | ||
| 241 | |||
| 242 | var previous_panel = null | ||
| 243 | var next_y = -100 | ||
| 244 | var words = ["quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"] | ||
| 245 | for word in words: | ||
| 246 | var panel = panel_prefab.instantiate() | ||
| 247 | panel.position = Vector3(0, next_y, 0) | ||
| 248 | next_y -= 10 | ||
| 249 | panel.clue = word | ||
| 250 | panel.symbol = "" | ||
| 251 | panel.answer = word | ||
| 252 | panel.name = "EndCheck_%s" % word | ||
| 253 | |||
| 254 | var tpl = tpl_prefab.instantiate() | ||
| 255 | tpl.teleport_point = Vector3(0, 1, 0) | ||
| 256 | tpl.teleport_rotate = Vector3(-45, 180, 0) | ||
| 257 | tpl.target_path = panel | ||
| 258 | tpl.name = "Teleport" | ||
| 259 | |||
| 260 | if previous_panel == null: | ||
| 261 | tpl.senders.append(NodePath("/root/scene/Panels/End/panel_24")) | ||
| 262 | else: | ||
| 263 | tpl.senders.append(NodePath("../../%s" % previous_panel.name)) | ||
| 264 | |||
| 265 | var reversing = reverse_prefab.instantiate() | ||
| 266 | reversing.senders.append(NodePath("..")) | ||
| 267 | reversing.name = "Reversing" | ||
| 268 | tpl.senders.append(NodePath("../Reversing")) | ||
| 269 | |||
| 270 | panel.add_child.call_deferred(tpl) | ||
| 271 | panel.add_child.call_deferred(reversing) | ||
| 272 | get_parent().get_node("Panels").add_child.call_deferred(panel) | ||
| 273 | |||
| 274 | previous_panel = panel | ||
| 275 | |||
| 276 | # Duplicate the doors that usually wait on EQUINOX. We can't set the senders | ||
| 277 | # here for some reason so we actually set them in the door ready function. | ||
| 278 | var endplat = get_node("/root/scene/Components/Doors/EndPlatform") | ||
| 279 | var endplat2 = endplat.duplicate() | ||
| 280 | endplat2.name = "spe_EndPlatform" | ||
| 281 | endplat.get_parent().add_child.call_deferred(endplat2) | ||
| 282 | endplat.queue_free() | ||
| 283 | |||
| 284 | var entry2 = get_node("/root/scene/Components/Doors/entry_2") | ||
| 285 | var entry22 = entry2.duplicate() | ||
| 286 | entry22.name = "spe_entry_2" | ||
| 287 | entry2.get_parent().add_child.call_deferred(entry22) | ||
| 288 | entry2.queue_free() | ||
| 289 | |||
| 290 | # Add the strict cyan ending validation. | ||
| 291 | if global.map == "the_parthenon" and ap.strict_cyan_ending: | ||
| 292 | var panel_prefab = preload("res://objects/nodes/panel.tscn") | ||
| 293 | var tpl_prefab = preload("res://objects/nodes/listeners/teleportListener.tscn") | ||
| 294 | var reverse_prefab = preload("res://objects/nodes/listeners/reversingListener.tscn") | ||
| 295 | |||
| 296 | var previous_panel = null | ||
| 297 | var next_y = -100 | ||
| 298 | var words = ["quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"] | ||
| 299 | for word in words: | ||
| 300 | var panel = panel_prefab.instantiate() | ||
| 301 | panel.position = Vector3(0, next_y, 0) | ||
| 302 | next_y -= 10 | ||
| 303 | panel.clue = word | ||
| 304 | panel.symbol = "." | ||
| 305 | panel.answer = "%s%s" % [word, word] | ||
| 306 | panel.name = "EndCheck_%s" % word | ||
| 307 | |||
| 308 | var tpl = tpl_prefab.instantiate() | ||
| 309 | tpl.teleport_point = Vector3(0, 1, -11) | ||
| 310 | tpl.teleport_rotate = Vector3(-45, 0, 0) | ||
| 311 | tpl.target_path = panel | ||
| 312 | tpl.name = "Teleport" | ||
| 313 | |||
| 314 | if previous_panel == null: | ||
| 315 | tpl.senderGroup.append(NodePath("/root/scene/Panels/Rulers")) | ||
| 316 | else: | ||
| 317 | tpl.senders.append(NodePath("../../%s" % previous_panel.name)) | ||
| 318 | |||
| 319 | var reversing = reverse_prefab.instantiate() | ||
| 320 | reversing.senders.append(NodePath("..")) | ||
| 321 | reversing.name = "Reversing" | ||
| 322 | tpl.senders.append(NodePath("../Reversing")) | ||
| 323 | |||
| 324 | panel.add_child.call_deferred(tpl) | ||
| 325 | panel.add_child.call_deferred(reversing) | ||
| 326 | get_parent().get_node("Panels").add_child.call_deferred(panel) | ||
| 327 | |||
| 328 | previous_panel = panel | ||
| 329 | |||
| 330 | # Duplicate the door that usually waits on the rulers. We can't set the | ||
| 331 | # senders here for some reason so we actually set them in the door ready | ||
| 332 | # function. | ||
| 333 | var entry1 = get_node("/root/scene/Components/Doors/entry_1") | ||
| 334 | var entry12 = entry1.duplicate() | ||
| 335 | entry12.name = "spe_entry_1" | ||
| 336 | entry1.get_parent().add_child.call_deferred(entry12) | ||
| 337 | entry1.queue_free() | ||
| 338 | |||
| 339 | var minimap = ap.SCRIPT_minimap.new() | ||
| 340 | minimap.name = "Minimap" | ||
| 341 | get_parent().add_child.call_deferred(minimap) | ||
| 342 | |||
| 343 | super._ready() | ||
| 344 | |||
| 345 | await get_tree().process_frame | ||
| 346 | await get_tree().process_frame | ||
| 347 | |||
| 348 | ap.stop_batching_locations() | ||
| 349 | |||
| 350 | |||
| 351 | func _set_up_invis_wall(x, y, z, sx, sy, sz): | ||
| 352 | var prefab = preload("res://objects/nodes/block.tscn") | ||
| 353 | var newwall = prefab.instantiate() | ||
| 354 | newwall.position.x = x | ||
| 355 | newwall.position.y = y | ||
| 356 | newwall.position.z = z | ||
| 357 | newwall.scale.x = sz | ||
| 358 | newwall.scale.y = sy | ||
| 359 | newwall.scale.z = sx | ||
| 360 | newwall.set_surface_override_material(0, preload("res://assets/materials/blackMatte.material")) | ||
| 361 | newwall.visibility_range_end = 3 | ||
| 362 | newwall.visibility_range_end_margin = 1 | ||
| 363 | newwall.visibility_range_fade_mode = RenderingServer.VISIBILITY_RANGE_FADE_SELF | ||
| 364 | newwall.skeleton = ".." | ||
| 365 | get_parent().add_child.call_deferred(newwall) | ||
| 366 | |||
| 367 | |||
| 368 | func _process(_dt): | ||
| 369 | compass.update_rotation(global_rotation.y) | ||
| diff --git a/client/Archipelago/rainbowText.gd b/client/Archipelago/rainbowText.gd deleted file mode 100644 index 9a4c1d0..0000000 --- a/client/Archipelago/rainbowText.gd +++ /dev/null | |||
| @@ -1,10 +0,0 @@ | |||
| 1 | extends RichTextEffect | ||
| 2 | |||
| 3 | var bbcode = "rainbow" | ||
| 4 | |||
| 5 | |||
| 6 | func _process_custom_fx(char_fx: CharFXTransform): | ||
| 7 | char_fx.color = Color.from_hsv( | ||
| 8 | char_fx.elapsed_time - floor(char_fx.elapsed_time), 1.0, 1.0, 1.0 | ||
| 9 | ) | ||
| 10 | return true | ||
| diff --git a/client/Archipelago/saver.gd b/client/Archipelago/saver.gd deleted file mode 100644 index 44bc179..0000000 --- a/client/Archipelago/saver.gd +++ /dev/null | |||
| @@ -1,23 +0,0 @@ | |||
| 1 | extends "res://scripts/nodes/saver.gd" | ||
| 2 | |||
| 3 | |||
| 4 | func levelLoaded(): | ||
| 5 | if type == "keyholders": | ||
| 6 | var ap = global.get_node("Archipelago") | ||
| 7 | ap.keyboard.load_keyholders.call_deferred(global.map) | ||
| 8 | else: | ||
| 9 | reload.call_deferred() | ||
| 10 | |||
| 11 | |||
| 12 | func reload(): | ||
| 13 | # Just rewriting this whole thing so I can remove Chris's safeguard. | ||
| 14 | var file = FileAccess.open(path + type + ".save", FileAccess.READ) | ||
| 15 | if file: | ||
| 16 | var data = file.get_var(true) | ||
| 17 | file.close() | ||
| 18 | for datum in data: | ||
| 19 | var saveable = get_node_or_null(datum[0]) | ||
| 20 | if saveable != null: | ||
| 21 | saveable.is_complete = datum[1] | ||
| 22 | if saveable.is_complete: | ||
| 23 | saveable.loadData(saveable.is_complete) | ||
| diff --git a/client/Archipelago/settings_buttons.gd b/client/Archipelago/settings_buttons.gd deleted file mode 100644 index 9e61cb0..0000000 --- a/client/Archipelago/settings_buttons.gd +++ /dev/null | |||
| @@ -1,24 +0,0 @@ | |||
| 1 | extends Button | ||
| 2 | |||
| 3 | |||
| 4 | func _ready(): | ||
| 5 | pass | ||
| 6 | |||
| 7 | |||
| 8 | func _connect_pressed(): | ||
| 9 | self.disabled = true | ||
| 10 | |||
| 11 | var ap = global.get_node("Archipelago") | ||
| 12 | ap.ap_server = self.get_parent().get_node("server_box").text | ||
| 13 | ap.ap_user = self.get_parent().get_node("player_box").text | ||
| 14 | ap.ap_pass = self.get_parent().get_node("password_box").text | ||
| 15 | ap.saveSettings() | ||
| 16 | |||
| 17 | ap.connectToServer() | ||
| 18 | |||
| 19 | |||
| 20 | func _back_pressed(): | ||
| 21 | var ap = global.get_node("Archipelago") | ||
| 22 | ap.disconnect_from_ap() | ||
| 23 | |||
| 24 | get_tree().change_scene_to_file("res://objects/scenes/menus/main_menu.tscn") | ||
| diff --git a/client/Archipelago/settings_screen.gd b/client/Archipelago/settings_screen.gd deleted file mode 100644 index d5aa747..0000000 --- a/client/Archipelago/settings_screen.gd +++ /dev/null | |||
| @@ -1,261 +0,0 @@ | |||
| 1 | extends Node2D | ||
| 2 | |||
| 3 | |||
| 4 | func _ready(): | ||
| 5 | # Some helpful logging. | ||
| 6 | if Steam.isSubscribed(): | ||
| 7 | global._print("Provisioning successful! Build ID: %d" % Steam.getAppBuildId()) | ||
| 8 | else: | ||
| 9 | global._print("Provisioning failed.") | ||
| 10 | |||
| 11 | # Undo the load screen removing our cursor | ||
| 12 | get_tree().get_root().set_disable_input(false) | ||
| 13 | Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE) | ||
| 14 | |||
| 15 | # Increase the WebSocket input buffer size so that we can download large | ||
| 16 | # data packages. | ||
| 17 | ProjectSettings.set_setting("network/limits/websocket_client/max_in_buffer_kb", 8192) | ||
| 18 | |||
| 19 | switcher.layer = 4 | ||
| 20 | |||
| 21 | # Create the global AP manager, if it doesn't already exist. | ||
| 22 | if not global.has_node("Archipelago"): | ||
| 23 | var ap_script = ResourceLoader.load("user://maps/Archipelago/manager.gd") | ||
| 24 | var ap_instance = ap_script.new() | ||
| 25 | ap_instance.name = "Archipelago" | ||
| 26 | |||
| 27 | ap_instance.SCRIPT_client = load("user://maps/Archipelago/client.gd") | ||
| 28 | ap_instance.SCRIPT_keyboard = load("user://maps/Archipelago/keyboard.gd") | ||
| 29 | ap_instance.SCRIPT_locationListener = load("user://maps/Archipelago/locationListener.gd") | ||
| 30 | ap_instance.SCRIPT_minimap = load("user://maps/Archipelago/minimap.gd") | ||
| 31 | ap_instance.SCRIPT_uuid = load("user://maps/Archipelago/vendor/uuid.gd") | ||
| 32 | ap_instance.SCRIPT_victoryListener = load("user://maps/Archipelago/victoryListener.gd") | ||
| 33 | |||
| 34 | global.add_child(ap_instance) | ||
| 35 | |||
| 36 | # Let's also inject any scripts we need to inject now. | ||
| 37 | installScriptExtension(ResourceLoader.load("user://maps/Archipelago/animationListener.gd")) | ||
| 38 | installScriptExtension(ResourceLoader.load("user://maps/Archipelago/collectable.gd")) | ||
| 39 | installScriptExtension(ResourceLoader.load("user://maps/Archipelago/door.gd")) | ||
| 40 | installScriptExtension(ResourceLoader.load("user://maps/Archipelago/keyHolder.gd")) | ||
| 41 | installScriptExtension(ResourceLoader.load("user://maps/Archipelago/keyHolderChecker.gd")) | ||
| 42 | installScriptExtension( | ||
| 43 | ResourceLoader.load("user://maps/Archipelago/keyHolderResetterListener.gd") | ||
| 44 | ) | ||
| 45 | installScriptExtension(ResourceLoader.load("user://maps/Archipelago/painting.gd")) | ||
| 46 | installScriptExtension(ResourceLoader.load("user://maps/Archipelago/panel.gd")) | ||
| 47 | installScriptExtension(ResourceLoader.load("user://maps/Archipelago/pauseMenu.gd")) | ||
| 48 | installScriptExtension(ResourceLoader.load("user://maps/Archipelago/player.gd")) | ||
| 49 | installScriptExtension(ResourceLoader.load("user://maps/Archipelago/saver.gd")) | ||
| 50 | installScriptExtension(ResourceLoader.load("user://maps/Archipelago/teleport.gd")) | ||
| 51 | installScriptExtension(ResourceLoader.load("user://maps/Archipelago/teleportListener.gd")) | ||
| 52 | installScriptExtension(ResourceLoader.load("user://maps/Archipelago/visibilityListener.gd")) | ||
| 53 | installScriptExtension(ResourceLoader.load("user://maps/Archipelago/worldport.gd")) | ||
| 54 | installScriptExtension(ResourceLoader.load("user://maps/Archipelago/worldportListener.gd")) | ||
| 55 | |||
| 56 | var proto_script = load("user://maps/Archipelago/generated/proto.gd") | ||
| 57 | var gamedata_script = load("user://maps/Archipelago/gamedata.gd") | ||
| 58 | var gamedata_instance = gamedata_script.new(proto_script) | ||
| 59 | gamedata_instance.load( | ||
| 60 | FileAccess.get_file_as_bytes("user://maps/Archipelago/generated/data.binpb") | ||
| 61 | ) | ||
| 62 | gamedata_instance.name = "Gamedata" | ||
| 63 | global.add_child(gamedata_instance) | ||
| 64 | |||
| 65 | var messages_script = load("user://maps/Archipelago/messages.gd") | ||
| 66 | var messages_instance = messages_script.new() | ||
| 67 | messages_instance.name = "Messages" | ||
| 68 | messages_instance.SCRIPT_rainbowText = load("user://maps/Archipelago/rainbowText.gd") | ||
| 69 | global.add_child(messages_instance) | ||
| 70 | |||
| 71 | var textclient_script = load("user://maps/Archipelago/textclient.gd") | ||
| 72 | var textclient_instance = textclient_script.new() | ||
| 73 | textclient_instance.name = "Textclient" | ||
| 74 | global.add_child(textclient_instance) | ||
| 75 | |||
| 76 | var compass_overlay_script = load("user://maps/Archipelago/compass_overlay.gd") | ||
| 77 | var compass_overlay_instance = compass_overlay_script.new() | ||
| 78 | compass_overlay_instance.name = "Compass" | ||
| 79 | compass_overlay_instance.SCRIPT_compass = load("user://maps/Archipelago/compass.gd") | ||
| 80 | global.add_child(compass_overlay_instance) | ||
| 81 | |||
| 82 | var ap = global.get_node("Archipelago") | ||
| 83 | var gamedata = global.get_node("Gamedata") | ||
| 84 | ap.connect("ap_connected", connectionSuccessful) | ||
| 85 | ap.connect("could_not_connect", connectionUnsuccessful) | ||
| 86 | ap.connect("connect_status", connectionStatus) | ||
| 87 | |||
| 88 | # Populate textboxes with AP settings. | ||
| 89 | $Panel/server_box.text = ap.ap_server | ||
| 90 | $Panel/player_box.text = ap.ap_user | ||
| 91 | $Panel/password_box.text = ap.ap_pass | ||
| 92 | |||
| 93 | var history_box = $Panel/connection_history | ||
| 94 | if ap.connection_history.is_empty(): | ||
| 95 | history_box.disabled = true | ||
| 96 | else: | ||
| 97 | history_box.disabled = false | ||
| 98 | |||
| 99 | var i = 0 | ||
| 100 | for details in ap.connection_history: | ||
| 101 | history_box.get_popup().add_item("%s (%s)" % [details[1], details[0]], i) | ||
| 102 | i += 1 | ||
| 103 | |||
| 104 | history_box.get_popup().connect("id_pressed", historySelected) | ||
| 105 | |||
| 106 | # Show client version. | ||
| 107 | $Panel/title.text = "ARCHIPELAGO (%d.%d)" % [gamedata.objects.get_version(), ap.MOD_VERSION] | ||
| 108 | |||
| 109 | # Increase font size in text boxes. | ||
| 110 | $Panel/server_box.add_theme_font_size_override("font_size", 36) | ||
| 111 | $Panel/player_box.add_theme_font_size_override("font_size", 36) | ||
| 112 | $Panel/password_box.add_theme_font_size_override("font_size", 36) | ||
| 113 | |||
| 114 | # Set up version mismatch dialog. | ||
| 115 | $Panel/VersionMismatch.connect("confirmed", startGame) | ||
| 116 | $Panel/VersionMismatch.get_cancel_button().pressed.connect(versionMismatchDeclined) | ||
| 117 | |||
| 118 | |||
| 119 | # Adapted from https://gitlab.com/Delta-V-Modding/Mods/-/blob/main/game/ModLoader.gd | ||
| 120 | func installScriptExtension(childScript: Resource): | ||
| 121 | # Force Godot to compile the script now. | ||
| 122 | # We need to do this here to ensure that the inheritance chain is | ||
| 123 | # properly set up, and multiple mods can chain-extend the same | ||
| 124 | # class multiple times. | ||
| 125 | # This is also needed to make Godot instantiate the extended class | ||
| 126 | # when creating singletons. | ||
| 127 | # The actual instance is thrown away. | ||
| 128 | childScript.new() | ||
| 129 | |||
| 130 | var parentScript = childScript.get_base_script() | ||
| 131 | var parentScriptPath = parentScript.resource_path | ||
| 132 | global._print("ModLoader: Installing script extension over %s" % parentScriptPath) | ||
| 133 | childScript.take_over_path(parentScriptPath) | ||
| 134 | |||
| 135 | |||
| 136 | func connectionStatus(message): | ||
| 137 | var popup = self.get_node("Panel/AcceptDialog") | ||
| 138 | popup.title = "Connecting to Archipelago" | ||
| 139 | popup.dialog_text = message | ||
| 140 | popup.exclusive = true | ||
| 141 | popup.get_ok_button().visible = false | ||
| 142 | popup.popup_centered() | ||
| 143 | |||
| 144 | |||
| 145 | func connectionSuccessful(): | ||
| 146 | var ap = global.get_node("Archipelago") | ||
| 147 | var gamedata = global.get_node("Gamedata") | ||
| 148 | |||
| 149 | # Check for major version mismatch. | ||
| 150 | if ap.apworld_version[0] != gamedata.objects.get_version(): | ||
| 151 | $Panel/AcceptDialog.exclusive = false | ||
| 152 | |||
| 153 | var popup = self.get_node("Panel/VersionMismatch") | ||
| 154 | popup.title = "Version Mismatch!" | ||
| 155 | popup.dialog_text = ( | ||
| 156 | "This slot was generated using v%d.%d of the Lingo 2 apworld,\nwhich has a different major version than this client (v%d.%d).\nIt is highly recommended to play using the correct version of the client.\nYou may experience bugs or logic issues if you continue." | ||
| 157 | % [ | ||
| 158 | ap.apworld_version[0], | ||
| 159 | ap.apworld_version[1], | ||
| 160 | gamedata.objects.get_version(), | ||
| 161 | ap.MOD_VERSION | ||
| 162 | ] | ||
| 163 | ) | ||
| 164 | popup.exclusive = true | ||
| 165 | popup.popup_centered() | ||
| 166 | |||
| 167 | return | ||
| 168 | |||
| 169 | startGame() | ||
| 170 | |||
| 171 | |||
| 172 | func startGame(): | ||
| 173 | var ap = global.get_node("Archipelago") | ||
| 174 | |||
| 175 | # Save connection details | ||
| 176 | var connection_details = [ap.ap_server, ap.ap_user, ap.ap_pass] | ||
| 177 | if ap.connection_history.has(connection_details): | ||
| 178 | ap.connection_history.erase(connection_details) | ||
| 179 | ap.connection_history.push_front(connection_details) | ||
| 180 | if ap.connection_history.size() > 10: | ||
| 181 | ap.connection_history.resize(10) | ||
| 182 | ap.saveSettings() | ||
| 183 | |||
| 184 | # Switch to the_entry | ||
| 185 | Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED) | ||
| 186 | global.user = ap.getSaveFileName() | ||
| 187 | global.universe = "lingo" | ||
| 188 | global.map = "the_entry" | ||
| 189 | |||
| 190 | unlocks.resetCollectables() | ||
| 191 | unlocks.resetData() | ||
| 192 | |||
| 193 | ap.setup_keys() | ||
| 194 | |||
| 195 | unlocks.loadCollectables() | ||
| 196 | unlocks.loadData() | ||
| 197 | unlocks.unlockKey("capslock", 1) | ||
| 198 | |||
| 199 | if ap.shuffle_worldports: | ||
| 200 | settings.worldport_fades = "default" | ||
| 201 | else: | ||
| 202 | settings.worldport_fades = "never" | ||
| 203 | |||
| 204 | clearResourceCache("res://objects/meshes/gridDoor.tscn") | ||
| 205 | clearResourceCache("res://objects/nodes/collectable.tscn") | ||
| 206 | clearResourceCache("res://objects/nodes/door.tscn") | ||
| 207 | clearResourceCache("res://objects/nodes/keyHolder.tscn") | ||
| 208 | clearResourceCache("res://objects/nodes/listeners/animationListener.tscn") | ||
| 209 | clearResourceCache("res://objects/nodes/listeners/keyHolderChecker.tscn") | ||
| 210 | clearResourceCache("res://objects/nodes/listeners/keyHolderResetterListener.tscn") | ||
| 211 | clearResourceCache("res://objects/nodes/listeners/teleportListener.tscn") | ||
| 212 | clearResourceCache("res://objects/nodes/listeners/visibilityListener.tscn") | ||
| 213 | clearResourceCache("res://objects/nodes/listeners/worldportListener.tscn") | ||
| 214 | clearResourceCache("res://objects/nodes/panel.tscn") | ||
| 215 | clearResourceCache("res://objects/nodes/player.tscn") | ||
| 216 | clearResourceCache("res://objects/nodes/saver.tscn") | ||
| 217 | clearResourceCache("res://objects/nodes/teleport.tscn") | ||
| 218 | clearResourceCache("res://objects/nodes/worldport.tscn") | ||
| 219 | clearResourceCache("res://objects/scenes/menus/pause_menu.tscn") | ||
| 220 | |||
| 221 | var paintings_dir = DirAccess.open("res://objects/meshes/paintings") | ||
| 222 | if paintings_dir: | ||
| 223 | paintings_dir.list_dir_begin() | ||
| 224 | var file_name = paintings_dir.get_next() | ||
| 225 | while file_name != "": | ||
| 226 | if not paintings_dir.current_is_dir() and file_name.ends_with(".tscn"): | ||
| 227 | clearResourceCache("res://objects/meshes/paintings/" + file_name) | ||
| 228 | file_name = paintings_dir.get_next() | ||
| 229 | |||
| 230 | switcher.switch_map.call_deferred("res://objects/scenes/the_entry.tscn") | ||
| 231 | |||
| 232 | |||
| 233 | func connectionUnsuccessful(error_message): | ||
| 234 | $Panel/connect_button.disabled = false | ||
| 235 | |||
| 236 | var popup = $Panel/AcceptDialog | ||
| 237 | popup.title = "Could not connect to Archipelago" | ||
| 238 | popup.dialog_text = error_message | ||
| 239 | popup.exclusive = true | ||
| 240 | popup.get_ok_button().visible = true | ||
| 241 | popup.popup_centered() | ||
| 242 | |||
| 243 | $Panel/connect_button.disabled = false | ||
| 244 | |||
| 245 | |||
| 246 | func versionMismatchDeclined(): | ||
| 247 | $Panel/AcceptDialog.hide() | ||
| 248 | $Panel/connect_button.disabled = false | ||
| 249 | |||
| 250 | |||
| 251 | func historySelected(index): | ||
| 252 | var ap = global.get_node("Archipelago") | ||
| 253 | var details = ap.connection_history[index] | ||
| 254 | |||
| 255 | $Panel/server_box.text = details[0] | ||
| 256 | $Panel/player_box.text = details[1] | ||
| 257 | $Panel/password_box.text = details[2] | ||
| 258 | |||
| 259 | |||
| 260 | func clearResourceCache(path): | ||
| 261 | ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_REPLACE) | ||
| diff --git a/client/Archipelago/teleport.gd b/client/Archipelago/teleport.gd deleted file mode 100644 index 428d50b..0000000 --- a/client/Archipelago/teleport.gd +++ /dev/null | |||
| @@ -1,38 +0,0 @@ | |||
| 1 | extends "res://scripts/nodes/teleport.gd" | ||
| 2 | |||
| 3 | var item_id | ||
| 4 | var item_amount | ||
| 5 | |||
| 6 | |||
| 7 | func _ready(): | ||
| 8 | var node_path = String( | ||
| 9 | get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names() | ||
| 10 | ) | ||
| 11 | |||
| 12 | var gamedata = global.get_node("Gamedata") | ||
| 13 | var door_id = gamedata.get_door_for_map_node_path(global.map, node_path) | ||
| 14 | if door_id != null: | ||
| 15 | var ap = global.get_node("Archipelago") | ||
| 16 | var item_lock = ap.get_item_id_for_door(door_id) | ||
| 17 | |||
| 18 | if item_lock != null: | ||
| 19 | item_id = item_lock[0] | ||
| 20 | item_amount = item_lock[1] | ||
| 21 | |||
| 22 | self.senders = [] | ||
| 23 | self.senderGroup = [] | ||
| 24 | self.nested = false | ||
| 25 | self.complete_at = 0 | ||
| 26 | self.max_length = 0 | ||
| 27 | self.excludeSenders = [] | ||
| 28 | |||
| 29 | call_deferred("_readier") | ||
| 30 | |||
| 31 | super._ready() | ||
| 32 | |||
| 33 | |||
| 34 | func _readier(): | ||
| 35 | var ap = global.get_node("Archipelago") | ||
| 36 | |||
| 37 | if ap.client.getItemAmount(item_id) >= item_amount: | ||
| 38 | handleTriggered() | ||
| diff --git a/client/Archipelago/teleportListener.gd b/client/Archipelago/teleportListener.gd deleted file mode 100644 index 6f363af..0000000 --- a/client/Archipelago/teleportListener.gd +++ /dev/null | |||
| @@ -1,49 +0,0 @@ | |||
| 1 | extends "res://scripts/nodes/listeners/teleportListener.gd" | ||
| 2 | |||
| 3 | var item_id | ||
| 4 | var item_amount | ||
| 5 | |||
| 6 | |||
| 7 | func _ready(): | ||
| 8 | var node_path = String( | ||
| 9 | get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names() | ||
| 10 | ) | ||
| 11 | |||
| 12 | if ( | ||
| 13 | global.map == "daedalus" | ||
| 14 | and ( | ||
| 15 | node_path == "Components/Triggers/teleportListenerConnections" | ||
| 16 | or node_path == "Components/Triggers/teleportListenerConnections2" | ||
| 17 | ) | ||
| 18 | ): | ||
| 19 | # Effectively disable these. | ||
| 20 | teleport_point = target_path.position | ||
| 21 | return | ||
| 22 | |||
| 23 | var gamedata = global.get_node("Gamedata") | ||
| 24 | var door_id = gamedata.get_door_for_map_node_path(global.map, node_path) | ||
| 25 | if door_id != null: | ||
| 26 | var ap = global.get_node("Archipelago") | ||
| 27 | var item_lock = ap.get_item_id_for_door(door_id) | ||
| 28 | |||
| 29 | if item_lock != null: | ||
| 30 | item_id = item_lock[0] | ||
| 31 | item_amount = item_lock[1] | ||
| 32 | |||
| 33 | self.senders = [] | ||
| 34 | self.senderGroup = [] | ||
| 35 | self.nested = false | ||
| 36 | self.complete_at = 0 | ||
| 37 | self.max_length = 0 | ||
| 38 | self.excludeSenders = [] | ||
| 39 | |||
| 40 | call_deferred("_readier") | ||
| 41 | |||
| 42 | super._ready() | ||
| 43 | |||
| 44 | |||
| 45 | func _readier(): | ||
| 46 | var ap = global.get_node("Archipelago") | ||
| 47 | |||
| 48 | if ap.client.getItemAmount(item_id) >= item_amount: | ||
| 49 | handleTriggered() | ||
| diff --git a/client/Archipelago/textclient.gd b/client/Archipelago/textclient.gd deleted file mode 100644 index 26831b4..0000000 --- a/client/Archipelago/textclient.gd +++ /dev/null | |||
| @@ -1,95 +0,0 @@ | |||
| 1 | extends CanvasLayer | ||
| 2 | |||
| 3 | var panel | ||
| 4 | var label | ||
| 5 | var entry | ||
| 6 | var is_open = false | ||
| 7 | |||
| 8 | |||
| 9 | func _ready(): | ||
| 10 | process_mode = ProcessMode.PROCESS_MODE_ALWAYS | ||
| 11 | layer = 2 | ||
| 12 | |||
| 13 | panel = Panel.new() | ||
| 14 | panel.set_name("Panel") | ||
| 15 | panel.offset_left = 100 | ||
| 16 | panel.offset_right = 1820 | ||
| 17 | panel.offset_top = 100 | ||
| 18 | panel.offset_bottom = 980 | ||
| 19 | panel.visible = false | ||
| 20 | add_child(panel) | ||
| 21 | |||
| 22 | label = RichTextLabel.new() | ||
| 23 | label.set_name("Label") | ||
| 24 | label.offset_left = 80 | ||
| 25 | label.offset_right = 1640 | ||
| 26 | label.offset_top = 80 | ||
| 27 | label.offset_bottom = 720 | ||
| 28 | label.scroll_following = true | ||
| 29 | label.selection_enabled = true | ||
| 30 | panel.add_child(label) | ||
| 31 | |||
| 32 | label.push_font(load("res://assets/fonts/Lingo2.ttf")) | ||
| 33 | label.push_font_size(36) | ||
| 34 | |||
| 35 | var entry_style = StyleBoxFlat.new() | ||
| 36 | entry_style.bg_color = Color(0.9, 0.9, 0.9, 1) | ||
| 37 | |||
| 38 | entry = LineEdit.new() | ||
| 39 | entry.set_name("Entry") | ||
| 40 | entry.offset_left = 80 | ||
| 41 | entry.offset_right = 1640 | ||
| 42 | entry.offset_top = 760 | ||
| 43 | entry.offset_bottom = 840 | ||
| 44 | entry.add_theme_font_override("font", load("res://assets/fonts/Lingo2.ttf")) | ||
| 45 | entry.add_theme_font_size_override("font_size", 36) | ||
| 46 | entry.add_theme_color_override("font_color", Color(0, 0, 0, 1)) | ||
| 47 | entry.add_theme_color_override("cursor_color", Color(0, 0, 0, 1)) | ||
| 48 | entry.add_theme_stylebox_override("focus", entry_style) | ||
| 49 | panel.add_child(entry) | ||
| 50 | entry.connect("text_submitted", text_entered) | ||
| 51 | |||
| 52 | |||
| 53 | func _input(event): | ||
| 54 | if global.loaded and event is InputEventKey and event.pressed: | ||
| 55 | if event.keycode == KEY_TAB and !Input.is_key_pressed(KEY_SHIFT): | ||
| 56 | if !get_tree().paused: | ||
| 57 | is_open = true | ||
| 58 | get_tree().paused = true | ||
| 59 | Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE) | ||
| 60 | panel.visible = true | ||
| 61 | entry.grab_focus() | ||
| 62 | get_viewport().set_input_as_handled() | ||
| 63 | else: | ||
| 64 | dismiss() | ||
| 65 | elif event.keycode == KEY_ESCAPE: | ||
| 66 | if is_open: | ||
| 67 | dismiss() | ||
| 68 | get_viewport().set_input_as_handled() | ||
| 69 | |||
| 70 | |||
| 71 | func dismiss(): | ||
| 72 | if is_open: | ||
| 73 | get_tree().paused = false | ||
| 74 | Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED) | ||
| 75 | panel.visible = false | ||
| 76 | is_open = false | ||
| 77 | |||
| 78 | |||
| 79 | func parse_printjson(text): | ||
| 80 | label.append_text("[p]" + text + "[/p]") | ||
| 81 | |||
| 82 | |||
| 83 | func text_entered(text): | ||
| 84 | var ap = global.get_node("Archipelago") | ||
| 85 | var cmd = text.trim_suffix("\n") | ||
| 86 | entry.text = "" | ||
| 87 | if OS.is_debug_build(): | ||
| 88 | if cmd.begins_with("/tp_map "): | ||
| 89 | var new_map = cmd.substr(8) | ||
| 90 | global.map = new_map | ||
| 91 | global.sets_entry_point = false | ||
| 92 | switcher.switch_map("res://objects/scenes/%s.tscn" % new_map) | ||
| 93 | return | ||
| 94 | |||
| 95 | ap.client.say(cmd) | ||
| diff --git a/client/Archipelago/vendor/LICENSE b/client/Archipelago/vendor/LICENSE deleted file mode 100644 index 115ba15..0000000 --- a/client/Archipelago/vendor/LICENSE +++ /dev/null | |||
| @@ -1,21 +0,0 @@ | |||
| 1 | MIT License | ||
| 2 | |||
| 3 | Copyright (c) 2023 Xavier Sellier | ||
| 4 | |||
| 5 | Permission is hereby granted, free of charge, to any person obtaining a copy | ||
| 6 | of this software and associated documentation files (the "Software"), to deal | ||
| 7 | in the Software without restriction, including without limitation the rights | ||
| 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
| 9 | copies of the Software, and to permit persons to whom the Software is | ||
| 10 | furnished to do so, subject to the following conditions: | ||
| 11 | |||
| 12 | The above copyright notice and this permission notice shall be included in all | ||
| 13 | copies or substantial portions of the Software. | ||
| 14 | |||
| 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
| 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
| 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
| 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
| 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
| 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | ||
| 21 | SOFTWARE. \ No newline at end of file | ||
| diff --git a/client/Archipelago/vendor/uuid.gd b/client/Archipelago/vendor/uuid.gd deleted file mode 100644 index b63fa04..0000000 --- a/client/Archipelago/vendor/uuid.gd +++ /dev/null | |||
| @@ -1,195 +0,0 @@ | |||
| 1 | # Note: The code might not be as pretty it could be, since it's written | ||
| 2 | # in a way that maximizes performance. Methods are inlined and loops are avoided. | ||
| 3 | extends Node | ||
| 4 | |||
| 5 | const BYTE_MASK: int = 0b11111111 | ||
| 6 | |||
| 7 | |||
| 8 | static func uuidbin(): | ||
| 9 | randomize() | ||
| 10 | # 16 random bytes with the bytes on index 6 and 8 modified | ||
| 11 | return [ | ||
| 12 | randi() & BYTE_MASK, | ||
| 13 | randi() & BYTE_MASK, | ||
| 14 | randi() & BYTE_MASK, | ||
| 15 | randi() & BYTE_MASK, | ||
| 16 | randi() & BYTE_MASK, | ||
| 17 | randi() & BYTE_MASK, | ||
| 18 | ((randi() & BYTE_MASK) & 0x0f) | 0x40, | ||
| 19 | randi() & BYTE_MASK, | ||
| 20 | ((randi() & BYTE_MASK) & 0x3f) | 0x80, | ||
| 21 | randi() & BYTE_MASK, | ||
| 22 | randi() & BYTE_MASK, | ||
| 23 | randi() & BYTE_MASK, | ||
| 24 | randi() & BYTE_MASK, | ||
| 25 | randi() & BYTE_MASK, | ||
| 26 | randi() & BYTE_MASK, | ||
| 27 | randi() & BYTE_MASK, | ||
| 28 | ] | ||
| 29 | |||
| 30 | |||
| 31 | static func uuidbinrng(rng: RandomNumberGenerator): | ||
| 32 | rng.randomize() | ||
| 33 | return [ | ||
| 34 | rng.randi() & BYTE_MASK, | ||
| 35 | rng.randi() & BYTE_MASK, | ||
| 36 | rng.randi() & BYTE_MASK, | ||
| 37 | rng.randi() & BYTE_MASK, | ||
| 38 | rng.randi() & BYTE_MASK, | ||
| 39 | rng.randi() & BYTE_MASK, | ||
| 40 | ((rng.randi() & BYTE_MASK) & 0x0f) | 0x40, | ||
| 41 | rng.randi() & BYTE_MASK, | ||
| 42 | ((rng.randi() & BYTE_MASK) & 0x3f) | 0x80, | ||
| 43 | rng.randi() & BYTE_MASK, | ||
| 44 | rng.randi() & BYTE_MASK, | ||
| 45 | rng.randi() & BYTE_MASK, | ||
| 46 | rng.randi() & BYTE_MASK, | ||
| 47 | rng.randi() & BYTE_MASK, | ||
| 48 | rng.randi() & BYTE_MASK, | ||
| 49 | rng.randi() & BYTE_MASK, | ||
| 50 | ] | ||
| 51 | |||
| 52 | |||
| 53 | static func v4(): | ||
| 54 | # 16 random bytes with the bytes on index 6 and 8 modified | ||
| 55 | var b = uuidbin() | ||
| 56 | |||
| 57 | return ( | ||
| 58 | "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x" | ||
| 59 | % [ | ||
| 60 | # low | ||
| 61 | b[0], | ||
| 62 | b[1], | ||
| 63 | b[2], | ||
| 64 | b[3], | ||
| 65 | # mid | ||
| 66 | b[4], | ||
| 67 | b[5], | ||
| 68 | # hi | ||
| 69 | b[6], | ||
| 70 | b[7], | ||
| 71 | # clock | ||
| 72 | b[8], | ||
| 73 | b[9], | ||
| 74 | # clock | ||
| 75 | b[10], | ||
| 76 | b[11], | ||
| 77 | b[12], | ||
| 78 | b[13], | ||
| 79 | b[14], | ||
| 80 | b[15] | ||
| 81 | ] | ||
| 82 | ) | ||
| 83 | |||
| 84 | |||
| 85 | static func v4_rng(rng: RandomNumberGenerator): | ||
| 86 | # 16 random bytes with the bytes on index 6 and 8 modified | ||
| 87 | var b = uuidbinrng(rng) | ||
| 88 | |||
| 89 | return ( | ||
| 90 | "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x" | ||
| 91 | % [ | ||
| 92 | # low | ||
| 93 | b[0], | ||
| 94 | b[1], | ||
| 95 | b[2], | ||
| 96 | b[3], | ||
| 97 | # mid | ||
| 98 | b[4], | ||
| 99 | b[5], | ||
| 100 | # hi | ||
| 101 | b[6], | ||
| 102 | b[7], | ||
| 103 | # clock | ||
| 104 | b[8], | ||
| 105 | b[9], | ||
| 106 | # clock | ||
| 107 | b[10], | ||
| 108 | b[11], | ||
| 109 | b[12], | ||
| 110 | b[13], | ||
| 111 | b[14], | ||
| 112 | b[15] | ||
| 113 | ] | ||
| 114 | ) | ||
| 115 | |||
| 116 | |||
| 117 | var _uuid: Array | ||
| 118 | |||
| 119 | |||
| 120 | func _init(rng := RandomNumberGenerator.new()) -> void: | ||
| 121 | _uuid = uuidbinrng(rng) | ||
| 122 | |||
| 123 | |||
| 124 | func as_array() -> Array: | ||
| 125 | return _uuid.duplicate() | ||
| 126 | |||
| 127 | |||
| 128 | func as_dict(big_endian := true) -> Dictionary: | ||
| 129 | if big_endian: | ||
| 130 | return { | ||
| 131 | "low": (_uuid[0] << 24) + (_uuid[1] << 16) + (_uuid[2] << 8) + _uuid[3], | ||
| 132 | "mid": (_uuid[4] << 8) + _uuid[5], | ||
| 133 | "hi": (_uuid[6] << 8) + _uuid[7], | ||
| 134 | "clock": (_uuid[8] << 8) + _uuid[9], | ||
| 135 | "node": | ||
| 136 | ( | ||
| 137 | (_uuid[10] << 40) | ||
| 138 | + (_uuid[11] << 32) | ||
| 139 | + (_uuid[12] << 24) | ||
| 140 | + (_uuid[13] << 16) | ||
| 141 | + (_uuid[14] << 8) | ||
| 142 | + _uuid[15] | ||
| 143 | ) | ||
| 144 | } | ||
| 145 | else: | ||
| 146 | return { | ||
| 147 | "low": _uuid[0] + (_uuid[1] << 8) + (_uuid[2] << 16) + (_uuid[3] << 24), | ||
| 148 | "mid": _uuid[4] + (_uuid[5] << 8), | ||
| 149 | "hi": _uuid[6] + (_uuid[7] << 8), | ||
| 150 | "clock": _uuid[8] + (_uuid[9] << 8), | ||
| 151 | "node": | ||
| 152 | ( | ||
| 153 | _uuid[10] | ||
| 154 | + (_uuid[11] << 8) | ||
| 155 | + (_uuid[12] << 16) | ||
| 156 | + (_uuid[13] << 24) | ||
| 157 | + (_uuid[14] << 32) | ||
| 158 | + (_uuid[15] << 40) | ||
| 159 | ) | ||
| 160 | } | ||
| 161 | |||
| 162 | |||
| 163 | func as_string() -> String: | ||
| 164 | return ( | ||
| 165 | "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x" | ||
| 166 | % [ | ||
| 167 | # low | ||
| 168 | _uuid[0], | ||
| 169 | _uuid[1], | ||
| 170 | _uuid[2], | ||
| 171 | _uuid[3], | ||
| 172 | # mid | ||
| 173 | _uuid[4], | ||
| 174 | _uuid[5], | ||
| 175 | # hi | ||
| 176 | _uuid[6], | ||
| 177 | _uuid[7], | ||
| 178 | # clock | ||
| 179 | _uuid[8], | ||
| 180 | _uuid[9], | ||
| 181 | # node | ||
| 182 | _uuid[10], | ||
| 183 | _uuid[11], | ||
| 184 | _uuid[12], | ||
| 185 | _uuid[13], | ||
| 186 | _uuid[14], | ||
| 187 | _uuid[15] | ||
| 188 | ] | ||
| 189 | ) | ||
| 190 | |||
| 191 | |||
| 192 | func is_equal(other) -> bool: | ||
| 193 | # Godot Engine compares Array recursively | ||
| 194 | # There's no need for custom comparison here. | ||
| 195 | return _uuid == other._uuid | ||
| diff --git a/client/Archipelago/victoryListener.gd b/client/Archipelago/victoryListener.gd deleted file mode 100644 index e9089d7..0000000 --- a/client/Archipelago/victoryListener.gd +++ /dev/null | |||
| @@ -1,20 +0,0 @@ | |||
| 1 | extends Receiver | ||
| 2 | |||
| 3 | |||
| 4 | func _ready(): | ||
| 5 | super._ready() | ||
| 6 | |||
| 7 | |||
| 8 | func handleTriggered(): | ||
| 9 | triggered += 1 | ||
| 10 | if triggered >= total: | ||
| 11 | var ap = global.get_node("Archipelago") | ||
| 12 | ap.client.completedGoal() | ||
| 13 | |||
| 14 | global.get_node("Messages").showMessage("You have completed your goal!") | ||
| 15 | |||
| 16 | |||
| 17 | func handleUntriggered(): | ||
| 18 | triggered -= 1 | ||
| 19 | if triggered < total: | ||
| 20 | pass | ||
| diff --git a/client/Archipelago/visibilityListener.gd b/client/Archipelago/visibilityListener.gd deleted file mode 100644 index 5ea17a0..0000000 --- a/client/Archipelago/visibilityListener.gd +++ /dev/null | |||
| @@ -1,38 +0,0 @@ | |||
| 1 | extends "res://scripts/nodes/listeners/visibilityListener.gd" | ||
| 2 | |||
| 3 | var item_id | ||
| 4 | var item_amount | ||
| 5 | |||
| 6 | |||
| 7 | func _ready(): | ||
| 8 | var node_path = String( | ||
| 9 | get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names() | ||
| 10 | ) | ||
| 11 | |||
| 12 | var gamedata = global.get_node("Gamedata") | ||
| 13 | var door_id = gamedata.get_door_for_map_node_path(global.map, node_path) | ||
| 14 | if door_id != null: | ||
| 15 | var ap = global.get_node("Archipelago") | ||
| 16 | var item_lock = ap.get_item_id_for_door(door_id) | ||
| 17 | |||
| 18 | if item_lock != null: | ||
| 19 | item_id = item_lock[0] | ||
| 20 | item_amount = item_lock[1] | ||
| 21 | |||
| 22 | self.senders = [] | ||
| 23 | self.senderGroup = [] | ||
| 24 | self.nested = false | ||
| 25 | self.complete_at = 0 | ||
| 26 | self.max_length = 0 | ||
| 27 | self.excludeSenders = [] | ||
| 28 | |||
| 29 | call_deferred("_readier") | ||
| 30 | |||
| 31 | super._ready() | ||
| 32 | |||
| 33 | |||
| 34 | func _readier(): | ||
| 35 | var ap = global.get_node("Archipelago") | ||
| 36 | |||
| 37 | if ap.client.getItemAmount(item_id) >= item_amount: | ||
| 38 | handleTriggered() | ||
| diff --git a/client/Archipelago/worldport.gd b/client/Archipelago/worldport.gd deleted file mode 100644 index cdca248..0000000 --- a/client/Archipelago/worldport.gd +++ /dev/null | |||
| @@ -1,53 +0,0 @@ | |||
| 1 | extends "res://scripts/nodes/worldport.gd" | ||
| 2 | |||
| 3 | var absolute_rotation = false | ||
| 4 | var target_rotation = 0 | ||
| 5 | |||
| 6 | |||
| 7 | func _ready(): | ||
| 8 | var node_path = String( | ||
| 9 | get_tree().get_root().get_node("scene").get_path_to(self).get_concatenated_names() | ||
| 10 | ) | ||
| 11 | |||
| 12 | var ap = global.get_node("Archipelago") | ||
| 13 | |||
| 14 | if ap.shuffle_worldports: | ||
| 15 | var gamedata = global.get_node("Gamedata") | ||
| 16 | var port_id = gamedata.get_port_for_map_node_path(global.map, node_path) | ||
| 17 | if port_id != null: | ||
| 18 | if port_id in ap.port_pairings: | ||
| 19 | var target_port = gamedata.objects.get_ports()[ap.port_pairings[port_id]] | ||
| 20 | var target_room = gamedata.objects.get_rooms()[target_port.get_room_id()] | ||
| 21 | var target_map = gamedata.objects.get_maps()[target_room.get_map_id()] | ||
| 22 | |||
| 23 | exit = target_map.get_name() | ||
| 24 | entry_point.x = target_port.get_destination().get_x() | ||
| 25 | entry_point.y = target_port.get_destination().get_y() | ||
| 26 | entry_point.z = target_port.get_destination().get_z() | ||
| 27 | absolute_rotation = true | ||
| 28 | target_rotation = target_port.get_rotation() | ||
| 29 | sets_entry_point = true | ||
| 30 | invisible = false | ||
| 31 | fades = true | ||
| 32 | |||
| 33 | if global.map == "icarus" and exit == "daedalus": | ||
| 34 | if not ap.daedalus_roof_access: | ||
| 35 | entry_point = Vector3(58, 10, 0) | ||
| 36 | |||
| 37 | super._ready() | ||
| 38 | |||
| 39 | |||
| 40 | func bodyEntered(body): | ||
| 41 | if body.is_in_group("player"): | ||
| 42 | if absolute_rotation: | ||
| 43 | entry_rotate.y = target_rotation - body.rotation_degrees.y | ||
| 44 | |||
| 45 | super.bodyEntered(body) | ||
| 46 | |||
| 47 | |||
| 48 | func changeScene(): | ||
| 49 | var player = get_tree().get_root().get_node("scene/player") | ||
| 50 | if player != null: | ||
| 51 | player.playable = false | ||
| 52 | |||
| 53 | super.changeScene() | ||
| diff --git a/client/Archipelago/worldportListener.gd b/client/Archipelago/worldportListener.gd deleted file mode 100644 index 5c2faff..0000000 --- a/client/Archipelago/worldportListener.gd +++ /dev/null | |||
| @@ -1,8 +0,0 @@ | |||
| 1 | extends "res://scripts/nodes/listeners/worldportListener.gd" | ||
| 2 | |||
| 3 | |||
| 4 | func handleTriggered(): | ||
| 5 | if exit == "menus/credits": | ||
| 6 | return | ||
| 7 | |||
| 8 | super.handleTriggered() | ||
