Merge branch 'main' into player-tracker

worlds/alttp/Bosses.py

@@ -1,8 +1,9 @@
 import logging
-from typing import Optional
+from typing import Optional, Union, List, Tuple, Callable, Dict
 
 from BaseClasses import Boss
 from Fill import FillError
+from .Options import Bosses
 
 
 def BossFactory(boss: str, player: int) -> Optional[Boss]:
@@ -12,7 +13,7 @@ def BossFactory(boss: str, player: int) -> Optional[Boss]:
     raise Exception('Unknown Boss: %s', boss)
 
 
-def ArmosKnightsDefeatRule(state, player: int):
+def ArmosKnightsDefeatRule(state, player: int) -> bool:
     # Magic amounts are probably a bit overkill
     return (
             state.has_melee_weapon(player) or
@@ -25,7 +26,7 @@ def ArmosKnightsDefeatRule(state, player: int):
             state.has('Red Boomerang', player))
 
 
-def LanmolasDefeatRule(state, player: int):
+def LanmolasDefeatRule(state, player: int) -> bool:
     return (
             state.has_melee_weapon(player) or
             state.has('Fire Rod', player) or
@@ -35,16 +36,16 @@ def LanmolasDefeatRule(state, player: int):
             state.can_shoot_arrows(player))
 
 
-def MoldormDefeatRule(state, player: int):
+def MoldormDefeatRule(state, player: int) -> bool:
     return state.has_melee_weapon(player)
 
 
-def HelmasaurKingDefeatRule(state, player: int):
+def HelmasaurKingDefeatRule(state, player: int) -> bool:
     # TODO: technically possible with the hammer
     return state.has_sword(player) or state.can_shoot_arrows(player)
 
 
-def ArrghusDefeatRule(state, player: int):
+def ArrghusDefeatRule(state, player: int) -> bool:
     if not state.has('Hookshot', player):
         return False
     # TODO: ideally we would have a check for bow and silvers, which combined with the
@@ -58,7 +59,7 @@ def ArrghusDefeatRule(state, player: int):
             (state.has('Ice Rod', player) and (state.can_shoot_arrows(player) or state.can_extend_magic(player, 16))))
 
 
-def MothulaDefeatRule(state, player: int):
+def MothulaDefeatRule(state, player: int) -> bool:
     return (
             state.has_melee_weapon(player) or
             (state.has('Fire Rod', player) and state.can_extend_magic(player, 10)) or
@@ -70,11 +71,11 @@ def MothulaDefeatRule(state, player: int):
     )
 
 
-def BlindDefeatRule(state, player: int):
+def BlindDefeatRule(state, player: int) -> bool:
     return state.has_melee_weapon(player) or state.has('Cane of Somaria', player) or state.has('Cane of Byrna', player)
 
 
-def KholdstareDefeatRule(state, player: int):
+def KholdstareDefeatRule(state, player: int) -> bool:
     return (
             (
                     state.has('Fire Rod', player) or
@@ -96,11 +97,11 @@ def KholdstareDefeatRule(state, player: int):
     )
 
 
-def VitreousDefeatRule(state, player: int):
+def VitreousDefeatRule(state, player: int) -> bool:
     return state.can_shoot_arrows(player) or state.has_melee_weapon(player)
 
 
-def TrinexxDefeatRule(state, player: int):
+def TrinexxDefeatRule(state, player: int) -> bool:
     if not (state.has('Fire Rod', player) and state.has('Ice Rod', player)):
         return False
     return state.has('Hammer', player) or state.has('Tempered Sword', player) or state.has('Golden Sword', player) or \
@@ -108,11 +109,11 @@ def TrinexxDefeatRule(state, player: int):
            (state.has_sword(player) and state.can_extend_magic(player, 32))
 
 
-def AgahnimDefeatRule(state, player: int):
+def AgahnimDefeatRule(state, player: int) -> bool:
     return state.has_sword(player) or state.has('Hammer', player) or state.has('Bug Catching Net', player)
 
 
-def GanonDefeatRule(state, player: int):
+def GanonDefeatRule(state, player: int) -> bool:
     if state.world.swordless[player]:
         return state.has('Hammer', player) and \
                state.has_fire_source(player) and \
@@ -132,7 +133,7 @@ def GanonDefeatRule(state, player: int):
         return common and state.has('Silver Bow', player) and state.can_shoot_arrows(player)
 
 
-boss_table = {
+boss_table: Dict[str, Tuple[str, Optional[Callable]]] = {
     'Armos Knights': ('Armos', ArmosKnightsDefeatRule),
     'Lanmolas': ('Lanmola', LanmolasDefeatRule),
     'Moldorm': ('Moldorm', MoldormDefeatRule),
@@ -147,7 +148,7 @@ boss_table = {
     'Agahnim2': ('Agahnim2', AgahnimDefeatRule)
 }
 
-boss_location_table = [
+boss_location_table: List[Tuple[str, str]] = [
         ('Ganons Tower', 'top'),
         ('Tower of Hera', None),
         ('Skull Woods', None),
@@ -164,6 +165,34 @@ boss_location_table = [
     ]
 
 
+def place_plando_bosses(bosses: List[str], world, player: int) -> Tuple[List[str], List[Tuple[str, str]]]:
+    # Most to least restrictive order
+    boss_locations = boss_location_table.copy()
+    world.random.shuffle(boss_locations)
+    boss_locations.sort(key=lambda location: -int(restrictive_boss_locations[location]))
+    already_placed_bosses: List[str] = []
+
+    for boss in bosses:
+        if "-" in boss:  # handle plando locations
+            loc, boss = boss.split("-")
+            boss = boss.title()
+            level: str = None
+            if loc.split(" ")[-1] in {"top", "middle", "bottom"}:
+                # split off level
+                loc = loc.split(" ")
+                level = loc[-1]
+                loc = " ".join(loc[:-1])
+            loc = loc.title().replace("Of", "of")
+            place_boss(world, player, boss, loc, level)
+            already_placed_bosses.append(boss)
+            boss_locations.remove((loc, level))
+        else:  # boss chosen with no specified locations
+            boss = boss.title()
+            boss_locations, already_placed_bosses = place_where_possible(world, player, boss, boss_locations)
+
+    return already_placed_bosses, boss_locations
+
+
 def can_place_boss(boss: str, dungeon_name: str, level: Optional[str] = None) -> bool:
     # blacklist approach
     if boss in {"Agahnim", "Agahnim2", "Ganon"}:
@@ -187,62 +216,50 @@ def can_place_boss(boss: str, dungeon_name: str, level: Optional[str] = None) ->
 
     return True
 
-restrictive_boss_locations = {}
+
+restrictive_boss_locations: Dict[Tuple[str, str], bool] = {}
 for location in boss_location_table:
     restrictive_boss_locations[location] = not all(can_place_boss(boss, *location)
                                                for boss in boss_table if not boss.startswith("Agahnim"))
 
-def place_boss(world, player: int, boss: str, location: str, level: Optional[str]):
+
+def place_boss(world, player: int, boss: str, location: str, level: Optional[str]) -> None:
     if location == 'Ganons Tower' and world.mode[player] == 'inverted':
         location = 'Inverted Ganons Tower'
     logging.debug('Placing boss %s at %s', boss, location + (' (' + level + ')' if level else ''))
     world.get_dungeon(location, player).bosses[level] = BossFactory(boss, player)
 
-def format_boss_location(location, level):
+
+def format_boss_location(location: str, level: str) -> str:
     return location + (' (' + level + ')' if level else '')
 
-def place_bosses(world, player: int):
-    if world.boss_shuffle[player] == 'none':
+
+def place_bosses(world, player: int) -> None:
+    # will either be an int or a lower case string with ';' between options
+    boss_shuffle: Union[str, int] = world.boss_shuffle[player].value
+    already_placed_bosses: List[str] = []
+    remaining_locations: List[Tuple[str, str]] = []
+    # handle plando
+    if isinstance(boss_shuffle, str):
+        # figure out our remaining mode, convert it to an int and remove it from plando_args
+        options = boss_shuffle.split(";")
+        boss_shuffle = Bosses.options[options.pop()]
+        # place our plando bosses
+        already_placed_bosses, remaining_locations = place_plando_bosses(options, world, player)
+    if boss_shuffle == Bosses.option_none:  # vanilla boss locations
         return
+
     # Most to least restrictive order
-    boss_locations = boss_location_table.copy()
-    world.random.shuffle(boss_locations)
-    boss_locations.sort(key= lambda location: -int(restrictive_boss_locations[location]))
+    if not remaining_locations and not already_placed_bosses:
+        remaining_locations = boss_location_table.copy()
+    world.random.shuffle(remaining_locations)
+    remaining_locations.sort(key=lambda location: -int(restrictive_boss_locations[location]))
 
     all_bosses = sorted(boss_table.keys())  # sorted to be deterministic on older pythons
     placeable_bosses = [boss for boss in all_bosses if boss not in ['Agahnim', 'Agahnim2', 'Ganon']]
 
-    shuffle_mode = world.boss_shuffle[player]
-    already_placed_bosses = []
-    if ";" in shuffle_mode:
-        bosses = shuffle_mode.split(";")
-        shuffle_mode = bosses.pop()
-        for boss in bosses:
-            if "-" in boss:
-                loc, boss = boss.split("-")
-                boss = boss.title()
-                level = None
-                if loc.split(" ")[-1] in {"top", "middle", "bottom"}:
-                    # split off level
-                    loc = loc.split(" ")
-                    level = loc[-1]
-                    loc = " ".join(loc[:-1])
-                loc = loc.title().replace("Of", "of")
-                if can_place_boss(boss, loc, level) and (loc, level) in boss_locations:
-                    place_boss(world, player, boss, loc, level)
-                    already_placed_bosses.append(boss)
-                    boss_locations.remove((loc, level))
-                else:
-                    raise Exception(f"Cannot place {boss} at {format_boss_location(loc, level)} for player {player}.")
-            else:
-                boss = boss.title()
-                boss_locations, already_placed_bosses = place_where_possible(world, player, boss, boss_locations)
-
-    if shuffle_mode == "none":
-        return  # vanilla bosses come pre-placed
-
-    if shuffle_mode in ["basic", "full"]:
-        if world.boss_shuffle[player] == "basic":  # vanilla bosses shuffled
+    if boss_shuffle == Bosses.option_basic or boss_shuffle == Bosses.option_full:
+        if boss_shuffle == Bosses.option_basic:  # vanilla bosses shuffled
             bosses = placeable_bosses + ['Armos Knights', 'Lanmolas', 'Moldorm']
         else:  # all bosses present, the three duplicates chosen at random
             bosses = placeable_bosses + world.random.sample(placeable_bosses, 3)
@@ -258,7 +275,7 @@ def place_bosses(world, player: int):
         logging.debug('Bosses chosen %s', bosses)
 
         world.random.shuffle(bosses)
-        for loc, level in boss_locations:
+        for loc, level in remaining_locations:
             for _ in range(len(bosses)):
                 boss = bosses.pop()
                 if can_place_boss(boss, loc, level):
@@ -272,8 +289,8 @@ def place_bosses(world, player: int):
 
             place_boss(world, player, boss, loc, level)
 
-    elif shuffle_mode == "chaos":  # all bosses chosen at random
-        for loc, level in boss_locations:
+    elif boss_shuffle == Bosses.option_chaos:  # all bosses chosen at random
+        for loc, level in remaining_locations:
             try:
                 boss = world.random.choice(
                     [b for b in placeable_bosses if can_place_boss(b, loc, level)])
@@ -282,9 +299,9 @@ def place_bosses(world, player: int):
             else:
                 place_boss(world, player, boss, loc, level)
 
-    elif shuffle_mode == "singularity":
+    elif boss_shuffle == Bosses.option_singularity:
         primary_boss = world.random.choice(placeable_bosses)
-        remaining_boss_locations, _ = place_where_possible(world, player, primary_boss, boss_locations)
+        remaining_boss_locations, _ = place_where_possible(world, player, primary_boss, remaining_locations)
         if remaining_boss_locations:
             # pick a boss to go into the remaining locations
             remaining_boss = world.random.choice([boss for boss in placeable_bosses if all(
@@ -293,12 +310,12 @@ def place_bosses(world, player: int):
             if remaining_boss_locations:
                 raise Exception("Unfilled boss locations!")
     else:
-        raise FillError(f"Could not find boss shuffle mode {shuffle_mode}")
+        raise FillError(f"Could not find boss shuffle mode {boss_shuffle}")
 
 
-def place_where_possible(world, player: int, boss: str, boss_locations):
-    remainder = []
-    placed_bosses = []
+def place_where_possible(world, player: int, boss: str, boss_locations) -> Tuple[List[Tuple[str, str]], List[str]]:
+    remainder: List[Tuple[str, str]] = []
+    placed_bosses: List[str] = []
     for loc, level in boss_locations:
         # place that boss where it can go
         if can_place_boss(boss, loc, level):

worlds/alttp/EntranceRandomizer.py

@@ -212,9 +212,7 @@ def parse_arguments(argv, no_defaults=False):
                              Alternatively, can be a ALttP Rom patched with a Link
                              sprite that will be extracted.
                              ''')
-    parser.add_argument('--gui', help='Launch the GUI', action='store_true')
 
-    parser.add_argument('--enemizercli', default=defval('EnemizerCLI/EnemizerCLI.Core'))
     parser.add_argument('--shufflebosses', default=defval('none'), choices=['none', 'basic', 'normal', 'chaos',
                                                                             "singularity"])
 

worlds/alttp/ItemPool.py

@@ -480,7 +480,7 @@ def set_up_take_anys(world, player):
     old_man_take_any.shop = TakeAny(old_man_take_any, 0x0112, 0xE2, True, True, total_shop_slots)
     world.shops.append(old_man_take_any.shop)
 
-    swords = [item for item in world.itempool if item.type == 'Sword' and item.player == player]
+    swords = [item for item in world.itempool if item.player == player and item.type == 'Sword']
     if swords:
         sword = world.random.choice(swords)
         world.itempool.remove(sword)

worlds/alttp/Options.py

@@ -1,7 +1,7 @@
 import typing
 
 from BaseClasses import MultiWorld
-from Options import Choice, Range, Option, Toggle, DefaultOnToggle, DeathLink
+from Options import Choice, Range, Option, Toggle, DefaultOnToggle, DeathLink, TextChoice
 
 
 class Logic(Choice):
@@ -39,8 +39,6 @@ class OpenPyramid(Choice):
     option_auto = 3
     default = option_goal
 
-    alias_true = option_open
-    alias_false = option_closed
     alias_yes = option_open
     alias_no = option_closed
 
@@ -140,13 +138,143 @@ class WorldState(Choice):
     option_inverted = 2
 
 
-class Bosses(Choice):
-    option_vanilla = 0
-    option_simple = 1
+class Bosses(TextChoice):
+    """Shuffles bosses around to different locations.
+    Basic will shuffle all bosses except Ganon and Agahnim anywhere they can be placed.
+    Full chooses 3 bosses at random to be placed twice instead of Lanmolas, Moldorm, and Helmasaur.
+    Chaos allows any boss to appear any number of times.
+    Singularity places a single boss in as many places as possible, and a second boss in any remaining locations.
+    Supports plando placement. Formatting here: https://archipelago.gg/tutorial/A%20Link%20to%20the%20Past/plando/en"""
+    display_name = "Boss Shuffle"
+    option_none = 0
+    option_basic = 1
     option_full = 2
     option_chaos = 3
     option_singularity = 4
 
+    bosses: set = {
+        "Armos Knights",
+        "Lanmolas",
+        "Moldorm",
+        "Helmasaur King",
+        "Arrghus",
+        "Mothula",
+        "Blind",
+        "Kholdstare",
+        "Vitreous",
+        "Trinexx",
+    }
+
+    locations: set = {
+        "Ganons Tower Top",
+        "Tower of Hera",
+        "Skull Woods",
+        "Ganons Tower Middle",
+        "Eastern Palace",
+        "Desert Palace",
+        "Palace of Darkness",
+        "Swamp Palace",
+        "Thieves Town",
+        "Ice Palace",
+        "Misery Mire",
+        "Turtle Rock",
+        "Ganons Tower Bottom"
+    }
+
+    def __init__(self, value: typing.Union[str, int]):
+        assert isinstance(value, str) or isinstance(value, int), \
+            f"{value} is not a valid option for {self.__class__.__name__}"
+        self.value = value
+
+    @classmethod
+    def from_text(cls, text: str):
+        import random
+        # set all of our text to lower case for name checking
+        text = text.lower()
+        cls.bosses = {boss_name.lower() for boss_name in cls.bosses}
+        cls.locations = {boss_location.lower() for boss_location in cls.locations}
+        if text == "random":
+            return cls(random.choice(list(cls.options.values())))
+        for option_name, value in cls.options.items():
+            if option_name == text:
+                return cls(value)
+        options = text.split(";")
+
+        # since plando exists in the option verify the plando values given are valid
+        cls.validate_plando_bosses(options)
+
+        # find out what type of boss shuffle we should use for placing bosses after plando
+        # and add as a string to look nice in the spoiler
+        if "random" in options:
+            shuffle = random.choice(list(cls.options))
+            options.remove("random")
+            options = ";".join(options) + ";" + shuffle
+            boss_class = cls(options)
+        else:
+            for option in options:
+                if option in cls.options:
+                    boss_class = cls(";".join(options))
+                    break
+            else:
+                if len(options) == 1:
+                    if cls.valid_boss_name(options[0]):
+                        options = options[0] + ";singularity"
+                        boss_class = cls(options)
+                    else:
+                        options = options[0] + ";none"
+                        boss_class = cls(options)
+                else:
+                    options = ";".join(options) + ";none"
+                    boss_class = cls(options)
+        return boss_class
+
+    @classmethod
+    def validate_plando_bosses(cls, options: typing.List[str]) -> None:
+        from .Bosses import can_place_boss, format_boss_location
+        for option in options:
+            if option == "random" or option in cls.options:
+                if option != options[-1]:
+                    raise ValueError(f"{option} option must be at the end of the boss_shuffle options!")
+                continue
+            if "-" in option:
+                location, boss = option.split("-")
+                level = ''
+                if not cls.valid_boss_name(boss):
+                    raise ValueError(f"{boss} is not a valid boss name for location {location}.")
+                if not cls.valid_location_name(location):
+                    raise ValueError(f"{location} is not a valid boss location name.")
+                if location.split(" ")[-1] in ("top", "middle", "bottom"):
+                    location = location.split(" ")
+                    level = location[-1]
+                    location = " ".join(location[:-1])
+                location = location.title().replace("Of", "of")
+                if not can_place_boss(boss.title(), location, level):
+                    raise ValueError(f"{format_boss_location(location, level)} "
+                                     f"is not a valid location for {boss.title()}.")
+            else:
+                if not cls.valid_boss_name(option):
+                    raise ValueError(f"{option} is not a valid boss name.")
+
+    @classmethod
+    def valid_boss_name(cls, value: str) -> bool:
+        return value.lower() in cls.bosses
+
+    @classmethod
+    def valid_location_name(cls, value: str) -> bool:
+        return value in cls.locations
+
+    def verify(self, world, player_name: str, plando_options) -> None:
+        if isinstance(self.value, int):
+            return
+        from Generate import PlandoSettings
+        if not(PlandoSettings.bosses & plando_options):
+            import logging
+            # plando is disabled but plando options were given so pull the option and change it to an int
+            option = self.value.split(";")[-1]
+            self.value = self.options[option]
+            logging.warning(f"The plando bosses module is turned off, so {self.name_lookup[self.value].title()} "
+                    f"boss shuffle will be used for player {player_name}.")
+
 
 class Enemies(Choice):
     option_vanilla = 0
@@ -159,8 +287,6 @@ class Progressive(Choice):
     option_off = 0
     option_grouped_random = 1
     option_on = 2
-    alias_false = 0
-    alias_true = 2
     default = 2
 
     def want_progressives(self, random):
@@ -168,8 +294,8 @@ class Progressive(Choice):
 
 
 class Swordless(Toggle):
-    """No swords. Curtains in Skull Woods and Agahnim\'s
-    Tower are removed, Agahnim\'s Tower barrier can be
+    """No swords. Curtains in Skull Woods and Agahnim's
+    Tower are removed, Agahnim's Tower barrier can be
     destroyed with hammer. Misery Mire and Turtle Rock
     can be opened without a sword. Hammer damages Ganon.
     Ether and Bombos Tablet can be activated with Hammer
@@ -202,8 +328,6 @@ class Hints(Choice):
     option_on = 2
     option_full = 3
     default = 2
-    alias_false = 0
-    alias_true = 2
 
 
 class Scams(Choice):
@@ -213,7 +337,6 @@ class Scams(Choice):
     option_king_zora = 1
     option_bottle_merchant = 2
     option_all = 3
-    alias_false = 0
 
     @property
     def gives_king_zora_hint(self):
@@ -282,8 +405,8 @@ class ShieldPalette(Palette):
     display_name = "Shield Palette"
 
 
-class LinkPalette(Palette):
-    display_name = "Link Palette"
+# class LinkPalette(Palette):
+#     display_name = "Link Palette"
 
 
 class HeartBeep(Choice):
@@ -293,7 +416,6 @@ class HeartBeep(Choice):
     option_half = 2
     option_quarter = 3
     option_off = 4
-    alias_false = 4
 
 
 class HeartColor(Choice):
@@ -375,6 +497,7 @@ alttp_options: typing.Dict[str, type(Option)] = {
     "hints": Hints,
     "scams": Scams,
     "restrict_dungeon_item_on_boss": RestrictBossItem,
+    "boss_shuffle": Bosses,
     "pot_shuffle": PotShuffle,
     "enemy_shuffle": EnemyShuffle,
     "killable_thieves": KillableThieves,
@@ -387,7 +510,7 @@ alttp_options: typing.Dict[str, type(Option)] = {
     "hud_palettes": HUDPalette,
     "sword_palettes": SwordPalette,
     "shield_palettes": ShieldPalette,
-    "link_palettes": LinkPalette,
+    # "link_palettes": LinkPalette,
     "heartbeep": HeartBeep,
     "heartcolor": HeartColor,
     "quickswap": QuickSwap,

worlds/alttp/Regions.py

@@ -4,6 +4,10 @@ import typing
 from BaseClasses import Region, Entrance, RegionType
 
 
+def is_main_entrance(entrance: Entrance) -> bool:
+    return entrance.parent_region.type in {RegionType.DarkWorld, RegionType.LightWorld, RegionType.Generic}
+
+
 def create_regions(world, player):
 
     world.regions += [

worlds/alttp/Rom.py

@@ -34,7 +34,7 @@ from worlds.alttp.Text import KingsReturn_texts, Sanctuary_texts, Kakariko_texts
     DeathMountain_texts, \
     LostWoods_texts, WishingWell_texts, DesertPalace_texts, MountainTower_texts, LinksHouse_texts, Lumberjacks_texts, \
     SickKid_texts, FluteBoy_texts, Zora_texts, MagicShop_texts, Sahasrahla_names
-from Utils import local_path, user_path, int16_as_bytes, int32_as_bytes, snes_to_pc, is_frozen
+from Utils import local_path, user_path, int16_as_bytes, int32_as_bytes, snes_to_pc, is_frozen, parse_yaml
 from worlds.alttp.Items import ItemFactory, item_table, item_name_groups, progression_items
 from worlds.alttp.EntranceShuffle import door_addresses
 from worlds.alttp.Options import smallkey_shuffle
@@ -551,18 +551,22 @@ class Sprite():
         Sprite.base_data = Sprite.sprite + Sprite.palette + Sprite.glove_palette
 
     def from_ap_sprite(self, filedata):
-        filedata = filedata.decode("utf-8-sig")
-        import yaml
-        obj = yaml.safe_load(filedata)
-        if obj["min_format_version"] > 1:
-            raise Exception("Sprite file requires an updated reader.")
-        self.author_name = obj["author"]
-        self.name = obj["name"]
-        if obj["data"]:  # skip patching for vanilla content
-            data = bsdiff4.patch(Sprite.base_data, obj["data"])
-            self.sprite = data[:self.sprite_size]
-            self.palette = data[self.sprite_size:self.palette_size]
-            self.glove_palette = data[self.sprite_size + self.palette_size:]
+        # noinspection PyBroadException
+        try:
+            obj = parse_yaml(filedata.decode("utf-8-sig"))
+            if obj["min_format_version"] > 1:
+                raise Exception("Sprite file requires an updated reader.")
+            self.author_name = obj["author"]
+            self.name = obj["name"]
+            if obj["data"]:  # skip patching for vanilla content
+                data = bsdiff4.patch(Sprite.base_data, obj["data"])
+                self.sprite = data[:self.sprite_size]
+                self.palette = data[self.sprite_size:self.palette_size]
+                self.glove_palette = data[self.sprite_size + self.palette_size:]
+        except Exception:
+            logger = logging.getLogger("apsprite")
+            logger.exception("Error parsing apsprite file")
+            self.valid = False
 
     @property
     def author_game_display(self) -> str:
@@ -659,7 +663,7 @@ class Sprite():
 
     @staticmethod
     def parse_zspr(filedata, expected_kind):
-        logger = logging.getLogger('ZSPR')
+        logger = logging.getLogger("ZSPR")
         headerstr = "<4xBHHIHIHH6x"
         headersize = struct.calcsize(headerstr)
         if len(filedata) < headersize:
@@ -667,7 +671,7 @@ class Sprite():
         version, csum, icsum, sprite_offset, sprite_size, palette_offset, palette_size, kind = struct.unpack_from(
             headerstr, filedata)
         if version not in [1]:
-            logger.error('Error parsing ZSPR file: Version %g not supported', version)
+            logger.error("Error parsing ZSPR file: Version %g not supported", version)
             return None
         if kind != expected_kind:
             return None
@@ -676,36 +680,42 @@ class Sprite():
         stream.seek(headersize)
 
         def read_utf16le(stream):
-            "Decodes a null-terminated UTF-16_LE string of unknown size from a stream"
+            """Decodes a null-terminated UTF-16_LE string of unknown size from a stream"""
             raw = bytearray()
             while True:
                 char = stream.read(2)
-                if char in [b'', b'\x00\x00']:
+                if char in [b"", b"\x00\x00"]:
                     break
                 raw += char
-            return raw.decode('utf-16_le')
+            return raw.decode("utf-16_le")
 
-        sprite_name = read_utf16le(stream)
-        author_name = read_utf16le(stream)
-        author_credits_name = stream.read().split(b"\x00", 1)[0].decode()
+        # noinspection PyBroadException
+        try:
+            sprite_name = read_utf16le(stream)
+            author_name = read_utf16le(stream)
+            author_credits_name = stream.read().split(b"\x00", 1)[0].decode()
 
-        # Ignoring the Author Rom name for the time being.
+            # Ignoring the Author Rom name for the time being.
 
-        real_csum = sum(filedata) % 0x10000
-        if real_csum != csum or real_csum ^ 0xFFFF != icsum:
-            logger.warning('ZSPR file has incorrect checksum. It may be corrupted.')
+            real_csum = sum(filedata) % 0x10000
+            if real_csum != csum or real_csum ^ 0xFFFF != icsum:
+                logger.warning("ZSPR file has incorrect checksum. It may be corrupted.")
 
-        sprite = filedata[sprite_offset:sprite_offset + sprite_size]
-        palette = filedata[palette_offset:palette_offset + palette_size]
+            sprite = filedata[sprite_offset:sprite_offset + sprite_size]
+            palette = filedata[palette_offset:palette_offset + palette_size]
 
-        if len(sprite) != sprite_size or len(palette) != palette_size:
-            logger.error('Error parsing ZSPR file: Unexpected end of file')
+            if len(sprite) != sprite_size or len(palette) != palette_size:
+                logger.error("Error parsing ZSPR file: Unexpected end of file")
+                return None
+
+            return sprite, palette, sprite_name, author_name, author_credits_name
+
+        except Exception:
+            logger.exception("Error parsing ZSPR file")
             return None
 
-        return (sprite, palette, sprite_name, author_name, author_credits_name)
-
     def decode_palette(self):
-        "Returns the palettes as an array of arrays of 15 colors"
+        """Returns the palettes as an array of arrays of 15 colors"""
 
         def array_chunk(arr, size):
             return list(zip(*[iter(arr)] * size))

worlds/alttp/__init__.py

@@ -4,6 +4,7 @@ import random
 import threading
 import typing
 
+import Utils
 from BaseClasses import Item, CollectionState, Tutorial
 from .Dungeons import create_dungeons
 from .EntranceShuffle import link_entrances, link_inverted_entrances, plando_connect
@@ -11,7 +12,8 @@ from .InvertedRegions import create_inverted_regions, mark_dark_world_regions
 from .ItemPool import generate_itempool, difficulties
 from .Items import item_init_table, item_name_groups, item_table, GetBeemizerItem
 from .Options import alttp_options, smallkey_shuffle
-from .Regions import lookup_name_to_id, create_regions, mark_light_world_regions
+from .Regions import lookup_name_to_id, create_regions, mark_light_world_regions, lookup_vanilla_location_to_entrance, \
+    is_main_entrance
 from .Rom import LocalRom, patch_rom, patch_race_rom, check_enemizer, patch_enemizer, apply_rom_settings, \
     get_hash_string, get_base_rom_path, LttPDeltaPatch
 from .Rules import set_rules
@@ -23,6 +25,7 @@ lttp_logger = logging.getLogger("A Link to the Past")
 
 extras_list = sum(difficulties['normal'].extras[0:5], [])
 
+
 class ALTTPWeb(WebWorld):
     setup_en = Tutorial(
         "Multiworld Setup Tutorial",
@@ -362,6 +365,10 @@ class ALTTPWorld(World):
 
     create_items = generate_itempool
 
+    enemizer_path: str = Utils.get_options()["generator"]["enemizer_path"] \
+        if os.path.isabs(Utils.get_options()["generator"]["enemizer_path"]) \
+        else Utils.local_path(Utils.get_options()["generator"]["enemizer_path"])
+
     def __init__(self, *args, **kwargs):
         self.dungeon_local_item_names = set()
         self.dungeon_specific_item_names = set()
@@ -376,12 +383,12 @@ class ALTTPWorld(World):
             raise FileNotFoundError(rom_file)
 
     def generate_early(self):
+        if self.use_enemizer():
+            check_enemizer(self.enemizer_path)
+
         player = self.player
         world = self.world
 
-        if self.use_enemizer():
-            check_enemizer(world.enemizer)
-
         # system for sharing ER layouts
         self.er_seed = str(world.random.randint(0, 2 ** 64))
 
@@ -570,7 +577,7 @@ class ALTTPWorld(World):
     def use_enemizer(self):
         world = self.world
         player = self.player
-        return (world.boss_shuffle[player] != 'none' or world.enemy_shuffle[player]
+        return (world.boss_shuffle[player] or world.enemy_shuffle[player]
                 or world.enemy_health[player] != 'default' or world.enemy_damage[player] != 'default'
                 or world.pot_shuffle[player] or world.bush_shuffle[player]
                 or world.killable_thieves[player])
@@ -586,7 +593,7 @@ class ALTTPWorld(World):
             patch_rom(world, rom, player, use_enemizer)
 
             if use_enemizer:
-                patch_enemizer(world, player, rom, world.enemizer, output_directory)
+                patch_enemizer(world, player, rom, self.enemizer_path, output_directory)
 
             if world.is_race:
                 patch_race_rom(rom, world, player)
@@ -599,7 +606,7 @@ class ALTTPWorld(World):
                 'hud': world.hud_palettes[player],
                 'sword': world.sword_palettes[player],
                 'shield': world.shield_palettes[player],
-                'link': world.link_palettes[player]
+                # 'link': world.link_palettes[player]
             }
             palettes_options = {key: option.current_key for key, option in palettes_options.items()}
 
@@ -631,6 +638,20 @@ class ALTTPWorld(World):
         finally:
             self.rom_name_available_event.set() # make sure threading continues and errors are collected
 
+    @classmethod
+    def stage_extend_hint_information(cls, world, hint_data: typing.Dict[int, typing.Dict[int, str]]):
+        er_hint_data = {player: {} for player in world.get_game_players("A Link to the Past") if
+                        world.shuffle[player] != "vanilla" or world.retro_caves[player]}
+
+        for region in world.regions:
+            if region.player in er_hint_data and region.locations:
+                main_entrance = region.get_connecting_entrance(is_main_entrance)
+                for location in region.locations:
+                    if type(location.address) == int:  # skips events and crystals
+                        if lookup_vanilla_location_to_entrance[location.address] != main_entrance.name:
+                            er_hint_data[region.player][location.address] = main_entrance.name
+        hint_data.update(er_hint_data)
+
     def modify_multidata(self, multidata: dict):
         import base64
         # wait for self.rom_name to be available.
@@ -645,8 +666,7 @@ class ALTTPWorld(World):
         return ALttPItem(name, self.player, **item_init_table[name])
 
     @classmethod
-    def stage_fill_hook(cls, world, progitempool, nonexcludeditempool, localrestitempool, nonlocalrestitempool,
-                        restitempool, fill_locations):
+    def stage_fill_hook(cls, world, progitempool, usefulitempool, filleritempool, fill_locations):
         trash_counts = {}
         standard_keyshuffle_players = set()
         for player in world.get_game_players("A Link to the Past"):
@@ -693,26 +713,15 @@ class ALTTPWorld(World):
             for player, trash_count in trash_counts.items():
                 gtower_locations = locations_mapping[player]
                 world.random.shuffle(gtower_locations)
-                localrest = localrestitempool[player]
-                if localrest:
-                    gt_item_pool = restitempool + localrest
-                    world.random.shuffle(gt_item_pool)
-                else:
-                    gt_item_pool = restitempool.copy()
 
-                while gtower_locations and gt_item_pool and trash_count > 0:
+                while gtower_locations and filleritempool and trash_count > 0:
                     spot_to_fill = gtower_locations.pop()
-                    item_to_place = gt_item_pool.pop()
+                    item_to_place = filleritempool.pop()
                     if spot_to_fill.item_rule(item_to_place):
-                        if item_to_place in localrest:
-                            localrest.remove(item_to_place)
-                        else:
-                            restitempool.remove(item_to_place)
                         world.push_item(spot_to_fill, item_to_place, False)
                         fill_locations.remove(spot_to_fill)  # very slow, unfortunately
                         trash_count -= 1
 
-
     def get_filler_item_name(self) -> str:
         if self.world.goal[self.player] == "icerodhunt":
             item = "Nothing"

worlds/alttp/docs/plando_en.md

@@ -26,10 +26,14 @@
         - Example: `Trinexx`
         - Takes a particular boss and places that boss in any remaining slots in which this boss can function.
         - In this example, it would fill Desert Palace, but not Tower of Hera.
+        - If no other options are provided this will follow normal singularity rules with that boss.
     - Boss Shuffle:
-        - Example: `simple`
+        - Example: `basic`
             - Runs a particular boss shuffle mode to finish construction instead of vanilla placement, typically used as
               a last instruction.
+            - Supports `random` which will choose a random option from the normal choices.
+            - If one is not supplied any remaining locations will be unshuffled unless a single specific boss is
+              supplied in which case it will use singularity as noted above.
 - [Available Bosses](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/Bosses.py#L135)
 - [Available Arenas](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/Bosses.py#L150)