extends Node
const MOD_VERSION = 3
var SCRIPT_client
var SCRIPT_keyboard
var SCRIPT_locationListener
var SCRIPT_uuid
var SCRIPT_victoryListener
var ap_server = ""
var ap_user = ""
var ap_pass = ""
var connection_history = []
var client
var keyboard
var _localdata_file = ""
var _last_new_item = -1
var _batch_locations = false
var _held_locations = []
var _held_location_scouts = []
var _location_scouts = {}
var _item_locks = {}
var _inverse_item_locks = {}
var _held_letters = {}
var _letters_setup = false
const kSHUFFLE_LETTERS_VANILLA = 0
const kSHUFFLE_LETTERS_UNLOCKED = 1
const kSHUFFLE_LETTERS_PROGRESSIVE = 2
const kSHUFFLE_LETTERS_VANILLA_CYAN = 3
const kSHUFFLE_LETTERS_ITEM_CYAN = 4
const kLETTER_BEHAVIOR_VANILLA = 0
const kLETTER_BEHAVIOR_ITEM = 1
const kLETTER_BEHAVIOR_UNLOCKED = 2
const kCYAN_DOOR_BEHAVIOR_H2 = 0
const kCYAN_DOOR_BEHAVIOR_DOUBLE_LETTER = 1
const kCYAN_DOOR_BEHAVIOR_ITEM = 2
var apworld_version = [0, 0]
var cyan_door_behavior = kCYAN_DOOR_BEHAVIOR_H2
var daedalus_roof_access = false
var keyholder_sanity = false
var shuffle_control_center_colors = false
var shuffle_doors = false
var shuffle_gallery_paintings = false
var shuffle_letters = kSHUFFLE_LETTERS_VANILLA
var shuffle_symbols = false
var victory_condition = -1
signal could_not_connect
signal connect_status
signal ap_connected
func _init():
# Read AP settings from file, if there are any
if FileAccess.file_exists("user://ap_settings"):
var file = FileAccess.open("user://ap_settings", FileAccess.READ)
var data = file.get_var(true)
file.close()
if typeof(data) != TYPE_ARRAY:
global._print("AP settings file is corrupted")
data = []
if data.size() > 0:
ap_server = data[0]
if data.size() > 1:
ap_user = data[1]
if data.size() > 2:
ap_pass = data[2]
if data.size() > 3:
connection_history = data[3]
func _ready():
client = SCRIPT_client.new()
client.SCRIPT_uuid = SCRIPT_uuid
client.connect("item_received", _process_item)
client.connect("message_received", _process_message)
client.connect("location_scout_received", _process_location_scout)
client.connect("could_not_connect", _client_could_not_connect)
client.connect("connect_status", _client_connect_status)
client.connect("client_connected", _client_connected)
add_child(client)
keyboard = SCRIPT_keyboard.new()
add_child(keyboard)
func saveSettings():
# Save the AP settings to disk.
var path = "user://ap_settings"
var file = FileAccess.open(path, FileAccess.WRITE)
var data = [
ap_server,
ap_user,
ap_pass,
connection_history,
]
file.store_var(data, true)
file.close()
func saveLocaldata():
# Save the MW/slot specific settings to disk.
var dir = DirAccess.open("user://")
var folder = "archipelago_data"
if not dir.dir_exists(folder):
dir.make_dir(folder)
var file = FileAccess.open(_localdata_file, FileAccess.WRITE)
var data = [
_last_new_item,
]
file.store_var(data, true)
file.close()
func connectToServer():
_last_new_item = -1
_batch_locations = false
_held_locations = []
_held_location_scouts = []
_location_scouts = {}
_letters_setup = false
_held_letters = {}
client.connectToServer(ap_server, ap_user, ap_pass)
func getSaveFileName():
return "zzAP_%s_%d" % [client._seed, client._slot]
func disconnect_from_ap():
client.disconnect_from_ap()
func get_item_id_for_door(door_id):
return _item_locks.get(door_id, null)
func _process_item(item, index, from, flags, amount):
var item_name = "Unknown"
if client._item_id_to_name["Lingo 2"].has(item):
item_name = client._item_id_to_name["Lingo 2"][item]
var gamedata = global.get_node("Gamedata")
var prog_id = null
if _inverse_item_locks.has(item):
for lock in _inverse_item_locks.get(item):
if lock[1] != amount:
continue
if gamedata.progressive_id_by_ap_id.has(item):
prog_id = lock[0]
if gamedata.get_door_map_name(lock[0]) != global.map:
continue
var receivers = gamedata.get_door_receivers(lock[0])
var scene = get_tree().get_root().get_node_or_null("scene")
if scene != null:
for receiver in receivers:
var rnode = scene.get_node_or_null(receiver)
if rnode != null:
rnode.handleTriggered()
var letter_id = gamedata.letter_id_by_ap_id.get(item, null)
if letter_id != null:
var letter = gamedata.objects.get_letters()[letter_id]
if not letter.has_level2() or not letter.get_level2():
_process_key_item(letter.get_key(), amount)
if gamedata.symbol_item_ids.has(item):
var player = get_tree().get_root().get_node_or_null("scene/player")
if player != null:
player.emit_signal("evaluate_solvability")
# Show a message about the item if it's new.
if index != null and index > _last_new_item:
_last_new_item = index
saveLocaldata()
var player_name = "Unknown"
if client._player_name_by_slot.has(float(from)):
player_name = client._player_name_by_slot[float(from)]
var item_color = colorForItemType(flags)
var full_item_name = item_name
if prog_id != null:
var door = gamedata.objects.get_doors()[prog_id]
full_item_name = "%s (%s)" % [item_name, door.get_name()]
var message
if from == client._slot:
message = "Found [color=%s]%s[/color]" % [item_color, full_item_name]
else:
message = (
"Received [color=%s]%s[/color] from %s" % [item_color, full_item_name, player_name]
)
if gamedata.anti_trap_ids.has(item):
keyboard.block_letter(gamedata.anti_trap_ids[item])
global._print(message)
global.get_node("Messages").showMessage(message)
func _process_message(message):
parse_printjson_for_textclient(message)
if (
!message.has("receiving")
or !message.has("item")
or message["item"]["player"] != client._slot
):
return
var item_name = "Unknown"
var item_player_game = client._game_by_player[message["receiving"]]
if client._item_id_to_name[item_player_game].has(int(message["item"]["item"])):
item_name = client._item_id_to_name[item_player_game][int(message["item"]["item"])]
var location_name = "Unknown"
var location_player_game = client._game_by_player[message["item"]["player"]]
if client._location_id_to_name[location_player_game].has(int(message["item"]["location"])):
location_name = (client._location_id_to_name[location_player_game][int(
message["item"]["location"]
)])
var player_name = "Unknown"
if client._player_name_by_slot.has(message["receiving"]):
player_name = client._player_name_by_slot[message["receiving"]]
var item_color = colorForItemType(message["item"]["flags"])
if message["type"] == "Hint":
var is_for = ""
if message["receiving"] != client._slot:
is_for = " for %s" % player_name
if !message.has("found") || !message["found"]:
global.get_node("Messages").showMessage(
(
"Hint: [color=%s]%s[/color]%s is on %s"
% [item_color, item_name, is_for, location_name]
)
)
else:
if message["receiving"] != client._slot:
var sentMsg = "Sent [color=%s]%s[/color] to %s" % [item_color, item_name, player_name]
#if _hinted_locations.has(message["item"]["location"]):
# sentMsg += " ([color=#fafad2]Hinted![/color])"
global.get_node("Messages").showMessage(sentMsg)
func parse_printjson_for_textclient(message):
var parts = []
for message_part in message["data"]:
if !message_part.has("type") and message_part.has("text"):
parts.append(message_part["text"])
elif message_part["type"] == "player_id":
if int(message_part["text"]) == client._slot:
parts.append(
"[color=#ee00ee]%s[/color]" % client._player_name_by_slot[client._slot]
)
else:
var from = float(message_part["text"])
parts.append("[color=#fafad2]%s[/color]" % client._player_name_by_slot[from])
elif message_part["type"] == "item_id":
var item_name = "Unknown"
var item_player_game = client._game_by_player[message_part["player"]]
if client._item_id_to_name[item_player_game].has(int(message_part["text"])):
item_name = client._item_id_to_name[item_player_game][int(message_part["text"])]
parts.append(
"[color=%s]%s[/color]" % [colorForItemType(message_part["flags"]), item_name]
)
elif message_part["type"] == "location_id":
var location_name = "Unknown"
var location_player_game = client._game_by_player[message_part["player"]]
if client._location_id_to_name[location_player_game].has(int(message_part["text"])):
location_name = client._location_id_to_name[location_player_game][int(
message_part["text"]
)]
parts.append("[color=#00ff7f]%s[/color]" % location_name)
elif message_part.has("text"):
parts.append(message_part["text"])
var textclient_node = global.get_node("Textclient")
if textclient_node != null:
textclient_node.parse_printjson("".join(parts))
func _process_location_scout(item_id, location_id, player, flags):
_location_scouts[location_id] = {"item": item_id, "player": player, "flags": flags}
var gamedata = global.get_node("Gamedata")
var map_id = gamedata.map_id_by_name.get(global.map)
var item_name = "Unknown"
var item_player_game = client._game_by_player[float(player)]
if client._item_id_to_name[item_player_game].has(item_id):
item_name = client._item_id_to_name[item_player_game][item_id]
var letter_id = gamedata.letter_id_by_ap_id.get(location_id, null)
if letter_id != null:
var letter = gamedata.objects.get_letters()[letter_id]
var room = gamedata.objects.get_rooms()[letter.get_room_id()]
if room.get_map_id() == map_id:
var collectable = get_tree().get_root().get_node("scene").get_node_or_null(
letter.get_path()
)
if collectable != null:
collectable.setScoutedText(item_name)
func _client_could_not_connect(message):
emit_signal("could_not_connect", message)
func _client_connect_status(message):
emit_signal("connect_status", message)
func _client_connected(slot_data):
var gamedata = global.get_node("Gamedata")
_localdata_file = "user://archipelago_data/%s_%d" % [client._seed, client._slot]
_last_new_item = -1
if FileAccess.file_exists(_localdata_file):
var ap_file = FileAccess.open(_localdata_file, FileAccess.READ)
var localdata = []
if ap_file != null:
localdata = ap_file.get_var(true)
ap_file.close()
if typeof(localdata) != TYPE_ARRAY:
print("AP localdata file is corrupted")
localdata = []
if localdata.size() > 0:
_last_new_item = localdata[0]
# Read slot data.
cyan_door_behavior = int(slot_data.get("cyan_door_behavior", 0))
daedalus_roof_access = bool(slot_data.get("daedalus_roof_access", false))
keyholder_sanity = bool(slot_data.get("keyholder_sanity", false))
shuffle_control_center_colors = bool(slot_data.get("shuffle_control_center_colors", false))
shuffle_doors = bool(slot_data.get("shuffle_doors", false))
shuffle_gallery_paintings = bool(slot_data.get("shuffle_gallery_paintings", false))
shuffle_letters = int(slot_data.get("shuffle_letters", 0))
shuffle_symbols = bool(slot_data.get("shuffle_symbols", false))
victory_condition = int(slot_data.get("victory_condition", 0))
if slot_data.has("version"):
apworld_version = [int(slot_data["version"][0]), int(slot_data["version"][1])]
# Set up item locks.
_item_locks = {}
if shuffle_doors:
for door in gamedata.objects.get_doors():
if (
door.get_type() == gamedata.SCRIPT_proto.DoorType.STANDARD
or door.get_type() == gamedata.SCRIPT_proto.DoorType.ITEM_ONLY
):
_item_locks[door.get_id()] = [door.get_ap_id(), 1]
for progressive in gamedata.objects.get_progressives():
for i in range(0, progressive.get_doors().size()):
var door = gamedata.objects.get_doors()[progressive.get_doors()[i]]
_item_locks[door.get_id()] = [progressive.get_ap_id(), i + 1]
for door_group in gamedata.objects.get_door_groups():
if (
door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.CONNECTOR
or door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.SHUFFLE_GROUP
):
for door in door_group.get_doors():
_item_locks[door] = [door_group.get_ap_id(), 1]
if shuffle_control_center_colors:
for door in gamedata.objects.get_doors():
if door.get_type() == gamedata.SCRIPT_proto.DoorType.CONTROL_CENTER_COLOR:
_item_locks[door.get_id()] = [door.get_ap_id(), 1]
for door_group in gamedata.objects.get_door_groups():
if door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.COLOR_CONNECTOR:
for door in door_group.get_doors():
_item_locks[door] = [door_group.get_ap_id(), 1]
if shuffle_gallery_paintings:
for door in gamedata.objects.get_doors():
if door.get_type() == gamedata.SCRIPT_proto.DoorType.GALLERY_PAINTING:
_item_locks[door.get_id()] = [door.get_ap_id(), 1]
if cyan_door_behavior == kCYAN_DOOR_BEHAVIOR_ITEM:
for door_group in gamedata.objects.get_door_groups():
if door_group.get_type() == gamedata.SCRIPT_proto.DoorGroupType.CYAN_DOORS:
for door in door_group.get_doors():
if not _item_locks.has(door):
_item_locks[door] = [door_group.get_ap_id(), 1]
# Create a reverse item locks map for processing items.
_inverse_item_locks = {}
for door_id in _item_locks.keys():
var lock = _item_locks.get(door_id)
if not _inverse_item_locks.has(lock[0]):
_inverse_item_locks[lock[0]] = []
_inverse_item_locks[lock[0]].append([door_id, lock[1]])
emit_signal("ap_connected")
func start_batching_locations():
_batch_locations = true
func send_location(loc_id):
if _batch_locations:
_held_locations.append(loc_id)
else:
client.sendLocation(loc_id)
func scout_location(loc_id):
if _location_scouts.has(loc_id):
return _location_scouts.get(loc_id)
if _batch_locations:
_held_location_scouts.append(loc_id)
else:
client.scoutLocation(loc_id)
return null
func stop_batching_locations():
_batch_locations = false
if not _held_locations.is_empty():
client.sendLocations(_held_locations)
_held_locations.clear()
if not _held_location_scouts.is_empty():
client.scoutLocations(_held_location_scouts)
_held_location_scouts.clear()
func colorForItemType(flags):
var int_flags = int(flags)
if int_flags & 1: # progression
if int_flags & 2: # proguseful
return "#f0d200"
else:
return "#bc51e0"
elif int_flags & 2: # useful
return "#2b67ff"
elif int_flags & 4: # trap
return "#d63a22"
else: # filler
return "#14de9e"
func get_letter_behavior(key, level2):
if shuffle_letters == kSHUFFLE_LETTERS_UNLOCKED:
return kLETTER_BEHAVIOR_UNLOCKED
if [kSHUFFLE_LETTERS_VANILLA_CYAN, kSHUFFLE_LETTERS_ITEM_CYAN].has(shuffle_letters):
if level2:
if shuffle_letters == kSHUFFLE_LETTERS_VANILLA_CYAN:
return kLETTER_BEHAVIOR_VANILLA
else:
return kLETTER_BEHAVIOR_ITEM
else:
return kLETTER_BEHAVIOR_UNLOCKED
if not level2 and ["h", "i", "n", "t"].has(key):
# This differs from the equivalent function in the apworld. Logically it is
# the same as UNLOCKED since they are in the starting room, but VANILLA
# means the player still has to actually pick up the letters.
return kLETTER_BEHAVIOR_VANILLA
if shuffle_letters == kSHUFFLE_LETTERS_PROGRESSIVE:
return kLETTER_BEHAVIOR_ITEM
return kLETTER_BEHAVIOR_VANILLA
func setup_keys():
keyboard.load_seed()
_letters_setup = true
for k in _held_letters.keys():
_process_key_item(k, _held_letters[k])
_held_letters.clear()
func _process_key_item(key, level):
if not _letters_setup:
_held_letters[key] = max(_held_letters.get(key, 0), level)
return
keyboard.collect_remote_letter(key, level)
6' href='#n366'>366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
|