from enum import IntEnum, auto from .generated import data_pb2 as data_pb2 from .items import SYMBOL_ITEMS from typing import TYPE_CHECKING, NamedTuple from .options import ShuffleLetters, CyanDoorBehavior if TYPE_CHECKING: from . import Lingo2World def calculate_letter_histogram(solution: str) -> dict[str, int]: histogram = dict() for l in solution: if l.isalpha(): real_l = l.upper() histogram[real_l] = min(histogram.get(real_l, 0) + 1, 2) return histogram class AccessRequirements: items: set[str] progressives: dict[str, int] rooms: set[str] letters: dict[str, int] cyans: bool # This is an AND of ORs. or_logic: list[list["AccessRequirements"]] # When complete_at is set, at least that many of the requirements in possibilities must be accessible. This should # only be used for doors with complete_at > 1, as or_logic is more efficient for complete_at == 1. complete_at: int | None possibilities: list["AccessRequirements"] def __init__(self): self.items = set() self.progressives = dict() self.rooms = set() self.letters = dict() self.cyans = False self.or_logic = list() self.complete_at = None self.possibilities = list() def copy(self) -> "AccessRequirements": reqs = AccessRequirements() reqs.items = self.items.copy() reqs.progressives = self.progressives.copy() reqs.rooms = self.rooms.copy() reqs.letters = self.letters.copy() reqs.cyans = self.cyans reqs.or_logic = [[other_req.copy() for other_req in disjunction] for disjunction in self.or_logic] reqs.complete_at = self.complete_at reqs.possibilities = self.possibilities.copy() return reqs def merge(self, other: "AccessRequirements"): for item in other.items: self.items.add(item) for item, amount in other.progressives.items(): self.progressives[item] = max(amount, self.progressives.get(item, 0)) for room in other.rooms: self.rooms.add(room) for letter, level in other.letters.items(): self.letters[letter] = max(self.letters.get(letter, 0), level) self.cyans = self.cyans or other.cyans for disjunction in other.or_logic: self.or_logic.append([sub_req.copy() for sub_req in disjunction]) if other.complete_at is not None: # Merging multiple requirements that use complete_at sucks, and is part of why we want to minimize use of # it. If both requirements use complete_at, we will cheat by using the or_logic field, which supports # conjunctions of requirements. if self.complete_at is not None: print("Merging requirements with complete_at > 1. This is messy and should be avoided!") left_req = AccessRequirements() left_req.complete_at = self.complete_at left_req.possibilities = [sub_req.copy() for sub_req in self.possibilities] self.or_logic.append([left_req]) self.complete_at = None self.possibilities = list() right_req = AccessRequirements() right_req.complete_at = other.complete_at right_req.possibilities = [sub_req.copy() for sub_req in other.possibilities] self.or_logic.append([right_req]) else: self.complete_at = other.complete_at self.possibilities = [sub_req.copy() for sub_req in other.possibilities] def is_empty(self) -> bool: return (len(self.items) == 0 and len(self.progressives) == 0 and len(self.rooms) == 0 and len(self.letters) == 0 and not self.cyans and len(self.or_logic) == 0 and self.complete_at is None) def __eq__(self, other: "AccessRequirements"): return (self.items == other.items and self.progressives == other.progressives and self.rooms == other.rooms and self.letters == other.letters and self.cyans == other.cyans and self.or_logic == other.or_logic and self.complete_at == other.complete_at and self.possibilities == other.possibilities) def simplify(self): resimplify = False if len(self.or_logic) > 0: old_or_logic = self.or_logic def remove_redundant(sub_reqs: "AccessRequirements"): new_reqs = sub_reqs.copy() new_reqs.letters = {l: v for l, v in new_reqs.letters.items() if self.letters.get(l, 0) < v} if new_reqs != sub_reqs: return new_reqs else: return sub_reqs self.or_logic = [] for disjunction in old_or_logic: new_disjunction = [] for ssr in disjunction: new_ssr = remove_redundant(ssr) if not new_ssr.is_empty(): new_disjunction.append(new_ssr) else: 
extends Node

var apworld_reader


func _init(path):
	apworld_reader = ZIPReader.new()
	apworld_reader.open(path)


func _get_true_path(path):
	if path.begins_with("../"):
		return "lingo2/%s" % path.substr(3)
	else:
		return "lingo2/client/%s" % path


func load_script(path):
	var true_path = _get_true_path(path)

	var script = GDScript.new()
	script.source_code = apworld_reader.read_file(true_path).get_string_from_utf8()
	script.reload()

	return script


func read_path(path):
	var true_path = _get_true_path(path)
	return apworld_reader.read_file(true_path)


func load_script_as_scene(path, scene_name):
	var script = load_script(path)
	var instance = script.new()
	instance.name = scene_name

	get_tree().unload_current_scene()
	_load_scene.call_deferred(instance)


func _load_scene(instance):
	get_tree().get_root().add_child(instance)
	get_tree().current_scene = instance
generated by cgit-pink 1.4.1 (git 2.36.1) at 2026-03-01 07:32:29 +0000
event_loc_item_by_room.setdefault(ending.room_id, {})[event_name] = "Victory" self.goal_room_id = ending.room_id if ending.name != "WHITE": event_name = f"{ending.name.capitalize()} Ending (Achieved)" self.event_loc_item_by_room.setdefault(ending.room_id, {})[event_name] = "Ending" if self.world.options.keyholder_sanity: for keyholder in world.static_logic.objects.keyholders: if keyholder.HasField("key"): if world.static_logic.get_room_object_map_id(keyholder) not in self.shuffled_maps: continue reqs = AccessRequirements() if self.get_letter_behavior(keyholder.key, False) != LetterBehavior.UNLOCKED: reqs.letters[keyholder.key.upper()] = 1 self.locations_by_room.setdefault(keyholder.room_id, []).append(PlayerLocation(keyholder.ap_id, reqs)) if self.world.options.shuffle_symbols: for symbol_name in SYMBOL_ITEMS.values(): self.real_items.append(symbol_name) def get_panel_reqs(self, panel_id: int, answer: str | None) -> AccessRequirements: if answer is None: if panel_id not in self.panel_reqs: self.panel_reqs[panel_id] = self.calculate_panel_reqs(panel_id, answer) return self.panel_reqs.get(panel_id) else: if panel_id not in self.proxy_reqs or answer not in self.proxy_reqs.get(panel_id): self.proxy_reqs.setdefault(panel_id, {})[answer] = self.calculate_panel_reqs(panel_id, answer) return self.proxy_reqs.get(panel_id).get(answer) def calculate_panel_reqs(self, panel_id: int, answer: str | None) -> AccessRequirements: panel = self.world.static_logic.objects.panels[panel_id] reqs = AccessRequirements() reqs.rooms.add(self.world.static_logic.get_room_region_name(panel.room_id)) if answer is not None: self.add_solution_reqs(reqs, answer) elif len(panel.proxies) > 0: possibilities = [] already_filled = False for proxy in panel.proxies: proxy_reqs = AccessRequirements() self.add_solution_reqs(proxy_reqs, proxy.answer) if not proxy_reqs.is_empty(): possibilities.append(proxy_reqs) else: already_filled = True break if not already_filled and not any(proxy.answer == panel.answer for proxy in panel.proxies): proxy_reqs = AccessRequirements() self.add_solution_reqs(proxy_reqs, panel.answer) if not proxy_reqs.is_empty(): possibilities.append(proxy_reqs) else: already_filled = True if not already_filled: reqs.or_logic.append(possibilities) else: self.add_solution_reqs(reqs, panel.answer) if self.world.options.shuffle_symbols: for symbol in panel.symbols: reqs.items.add(SYMBOL_ITEMS.get(symbol)) if panel.HasField("required_door"): door_reqs = self.get_door_open_reqs(panel.required_door) reqs.merge(door_reqs) if panel.HasField("required_room"): reqs.rooms.add(self.world.static_logic.get_room_region_name(panel.required_room)) return reqs # This gets/calculates the requirements described by the door object. This is most notably used as the requirements # for clearing a location, or opening a door when the door is not shuffled. def get_door_reqs(self, door_id: int) -> AccessRequirements: if door_id not in self.door_reqs: self.door_reqs[door_id] = self.calculate_door_reqs(door_id) return self.door_reqs.get(door_id) def calculate_door_reqs(self, door_id: int) -> AccessRequirements: door = self.world.static_logic.objects.doors[door_id] reqs = AccessRequirements() if not door.HasField("complete_at") or door.complete_at == 0: for proxy in door.panels: panel_reqs = self.get_panel_reqs(proxy.panel, proxy.answer if proxy.HasField("answer") else None) reqs.merge(panel_reqs) elif door.complete_at == 1: disjunction = [] for proxy in door.panels: proxy_reqs = self.get_panel_reqs(proxy.panel, proxy.answer if proxy.HasField("answer") else None) if proxy_reqs.is_empty(): disjunction.clear() break else: disjunction.append(proxy_reqs) if len(disjunction) > 0: reqs.or_logic.append(disjunction) else: reqs.complete_at = door.complete_at for proxy in door.panels: panel_reqs = self.get_panel_reqs(proxy.panel, proxy.answer if proxy.HasField("answer") else None) reqs.possibilities.append(panel_reqs) if door.HasField("control_center_color"): reqs.rooms.add("Control Center - Main Area") self.add_solution_reqs(reqs, door.control_center_color) if door.double_letters: if self.world.options.cyan_door_behavior == CyanDoorBehavior.option_collect_h2: reqs.rooms.add("The Repetitive - Main Room") elif self.world.options.cyan_door_behavior == CyanDoorBehavior.option_any_double_letter: if self.world.options.shuffle_letters != ShuffleLetters.option_unlocked: reqs.cyans = True elif self.world.options.cyan_door_behavior == CyanDoorBehavior.option_item: # There shouldn't be any locations that are cyan doors. pass for keyholder_uses in door.keyholders: key_name = keyholder_uses.key.upper() if (self.get_letter_behavior(keyholder_uses.key, False) != LetterBehavior.UNLOCKED and key_name not in reqs.letters): reqs.letters[key_name] = 1 keyholder = self.world.static_logic.objects.keyholders[keyholder_uses.keyholder] reqs.rooms.add(self.world.static_logic.get_room_region_name(keyholder.room_id)) for room in door.rooms: reqs.rooms.add(self.world.static_logic.get_room_region_name(room)) if door.white_ending: if self.world.options.endings_requirement > 0: reqs.progressives["Ending"] = self.world.options.endings_requirement.value if self.world.options.masteries_requirement > 0: reqs.progressives["Mastery"] = self.world.options.masteries_requirement.value for sub_door_id in door.doors: sub_reqs = self.get_door_open_reqs(sub_door_id) reqs.merge(sub_reqs) reqs.simplify() return reqs # This gets the requirements to open a door within the world. When a door is shuffled, this means having the item # that acts as the door's key. def get_door_open_reqs(self, door_id: int) -> AccessRequirements: if door_id in self.item_by_door: reqs = AccessRequirements() item_name, amount = self.item_by_door.get(door_id) if amount == 1: reqs.items.add(item_name) else: reqs.progressives[item_name] = amount return reqs else: return self.get_door_reqs(door_id) def get_letter_behavior(self, letter: str, level2: bool) -> LetterBehavior: if self.world.options.shuffle_letters == ShuffleLetters.option_unlocked: return LetterBehavior.UNLOCKED if self.world.options.shuffle_letters in [ShuffleLetters.option_vanilla_cyan, ShuffleLetters.option_item_cyan]: if level2: if self.world.options.shuffle_letters == ShuffleLetters.option_vanilla_cyan: return LetterBehavior.VANILLA else: return LetterBehavior.ITEM else: return LetterBehavior.UNLOCKED if not level2 and letter in ["h", "i", "n", "t"]: return LetterBehavior.UNLOCKED if self.world.options.shuffle_letters == ShuffleLetters.option_progressive: return LetterBehavior.ITEM return LetterBehavior.VANILLA def add_solution_reqs(self, reqs: AccessRequirements, solution: str): histogram = calculate_letter_histogram(solution) for l, a in histogram.items(): needed = min(a, 2) level2 = (needed == 2) if level2 and self.get_letter_behavior(l.lower(), True) == LetterBehavior.UNLOCKED: needed = 1 if self.get_letter_behavior(l.lower(), False) == LetterBehavior.UNLOCKED: needed = needed - 1 if needed > 0: reqs.letters[l] = max(reqs.letters.get(l, 0), needed) if any(l.isnumeric() for l in solution): reqs.items.add("Numbers")