From 05aa96a33573b97c93a2e252994699050e262252 Mon Sep 17 00:00:00 2001
From: black-sliver <59490463+black-sliver@users.noreply.github.com>
Date: Fri, 29 Nov 2024 20:07:14 +0100
Subject: [PATCH 01/20] CI: use py3.12 for the linux and windows builds (#4284)

* CI: use py3.12 for the linux build

* CI: use py3.12 for the windows build
---
 .github/workflows/build.yml   | 6 +++---
 .github/workflows/release.yml | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index c013172ea034..a5a2f52f3222 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -31,7 +31,7 @@ jobs:
       - name: Install python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.10'
+          python-version: '3.12'
       - name: Download run-time dependencies
         run: |
           Invoke-WebRequest -Uri https://github.com/Ijwu/Enemizer/releases/download/${Env:ENEMIZER_VERSION}/win-x64.zip -OutFile enemizer.zip
@@ -111,10 +111,10 @@ jobs:
       - name: Get a recent python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.11'
+          python-version: '3.12'
       - name: Install build-time dependencies
         run: |
-          echo "PYTHON=python3.11" >> $GITHUB_ENV
+          echo "PYTHON=python3.12" >> $GITHUB_ENV
           wget -nv https://github.com/AppImage/AppImageKit/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
           chmod a+rx appimagetool-x86_64.AppImage
           ./appimagetool-x86_64.AppImage --appimage-extract
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 3f8651d408e7..b28ec8733408 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -44,10 +44,10 @@ jobs:
       - name: Get a recent python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.11'
+          python-version: '3.12'
       - name: Install build-time dependencies
         run: |
-          echo "PYTHON=python3.11" >> $GITHUB_ENV
+          echo "PYTHON=python3.12" >> $GITHUB_ENV
           wget -nv https://github.com/AppImage/AppImageKit/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
           chmod a+rx appimagetool-x86_64.AppImage
           ./appimagetool-x86_64.AppImage --appimage-extract

From d36c9834612a35cdeb84f43e6609ff5021c5f235 Mon Sep 17 00:00:00 2001
From: Benjamin S Wolf <jokeserver@gmail.com>
Date: Fri, 29 Nov 2024 11:40:02 -0800
Subject: [PATCH 02/20] Core: Log warnings at call site, not Utils itself
 (#4229)

---
 Utils.py | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/Utils.py b/Utils.py
index 4e8d7fc427e0..f5c6ca6414f5 100644
--- a/Utils.py
+++ b/Utils.py
@@ -858,11 +858,10 @@ def async_start(co: Coroutine[None, None, typing.Any], name: Optional[str] = Non
     task.add_done_callback(_faf_tasks.discard)
 
 
-def deprecate(message: str):
+def deprecate(message: str, add_stacklevels: int = 0):
     if __debug__:
         raise Exception(message)
-    import warnings
-    warnings.warn(message)
+    warnings.warn(message, stacklevel=2 + add_stacklevels)
 
 
 class DeprecateDict(dict):
@@ -876,10 +875,9 @@ def __init__(self, message: str, error: bool = False) -> None:
 
     def __getitem__(self, item: Any) -> Any:
         if self.should_error:
-            deprecate(self.log_message)
+            deprecate(self.log_message, add_stacklevels=1)
         elif __debug__:
-            import warnings
-            warnings.warn(self.log_message)
+            warnings.warn(self.log_message, stacklevel=2)
         return super().__getitem__(item)
 
 

From ed4e44b99403fedb27ab933e50068192bf2a4e7a Mon Sep 17 00:00:00 2001
From: Jouramie <16137441+Jouramie@users.noreply.github.com>
Date: Fri, 29 Nov 2024 14:41:26 -0500
Subject: [PATCH 03/20] Stardew Valley: Remove some events for a slight
 performance increase (#4085)

---
 worlds/stardew_valley/__init__.py             | 15 -------
 worlds/stardew_valley/logic/building_logic.py | 11 +++--
 worlds/stardew_valley/logic/money_logic.py    | 13 ++++--
 worlds/stardew_valley/logic/shipping_logic.py |  5 +--
 .../logic/special_order_logic.py              |  7 ++--
 worlds/stardew_valley/rules.py                | 40 ++++++++-----------
 .../stardew_rule/rule_explain.py              | 20 +++++-----
 .../strings/ap_names/event_names.py           |  4 --
 .../test/rules/TestBuildings.py               |  9 -----
 9 files changed, 48 insertions(+), 76 deletions(-)

diff --git a/worlds/stardew_valley/__init__.py b/worlds/stardew_valley/__init__.py
index 44306011361c..01ca56531f00 100644
--- a/worlds/stardew_valley/__init__.py
+++ b/worlds/stardew_valley/__init__.py
@@ -206,25 +206,10 @@ def precollect_farm_type_items(self):
             self.multiworld.push_precollected(self.create_starting_item("Progressive Coop"))
 
     def setup_player_events(self):
-        self.setup_construction_events()
-        self.setup_quest_events()
         self.setup_action_events()
         self.setup_logic_events()
 
-    def setup_construction_events(self):
-        can_construct_buildings = LocationData(None, RegionName.carpenter, Event.can_construct_buildings)
-        self.create_event_location(can_construct_buildings, True_(), Event.can_construct_buildings)
-
-    def setup_quest_events(self):
-        start_dark_talisman_quest = LocationData(None, RegionName.railroad, Event.start_dark_talisman_quest)
-        self.create_event_location(start_dark_talisman_quest, self.logic.wallet.has_rusty_key(), Event.start_dark_talisman_quest)
-
     def setup_action_events(self):
-        can_ship_event = LocationData(None, LogicRegion.shipping, Event.can_ship_items)
-        self.create_event_location(can_ship_event, true_, Event.can_ship_items)
-        can_shop_pierre_event = LocationData(None, RegionName.pierre_store, Event.can_shop_at_pierre)
-        self.create_event_location(can_shop_pierre_event, true_, Event.can_shop_at_pierre)
-
         spring_farming = LocationData(None, LogicRegion.spring_farming, Event.spring_farming)
         self.create_event_location(spring_farming, true_, Event.spring_farming)
         summer_farming = LocationData(None, LogicRegion.summer_farming, Event.summer_farming)
diff --git a/worlds/stardew_valley/logic/building_logic.py b/worlds/stardew_valley/logic/building_logic.py
index 4611eba37d64..b4eff4399385 100644
--- a/worlds/stardew_valley/logic/building_logic.py
+++ b/worlds/stardew_valley/logic/building_logic.py
@@ -1,3 +1,4 @@
+from functools import cached_property
 from typing import Dict, Union
 
 from Utils import cache_self1
@@ -8,12 +9,12 @@
 from .region_logic import RegionLogicMixin
 from ..options import BuildingProgression
 from ..stardew_rule import StardewRule, True_, False_, Has
-from ..strings.ap_names.event_names import Event
 from ..strings.artisan_good_names import ArtisanGood
 from ..strings.building_names import Building
 from ..strings.fish_names import WaterItem
 from ..strings.material_names import Material
 from ..strings.metal_names import MetalBar
+from ..strings.region_names import Region
 
 has_group = "building"
 
@@ -60,7 +61,7 @@ def has_building(self, building: str) -> StardewRule:
                 return True_()
             return self.logic.received(building)
 
-        carpenter_rule = self.logic.received(Event.can_construct_buildings)
+        carpenter_rule = self.logic.building.can_construct_buildings
         if not self.options.building_progression & BuildingProgression.option_progressive:
             return Has(building, self.registry.building_rules, has_group) & carpenter_rule
 
@@ -75,6 +76,10 @@ def has_building(self, building: str) -> StardewRule:
             building = " ".join(["Progressive", *building.split(" ")[1:]])
         return self.logic.received(building, count) & carpenter_rule
 
+    @cached_property
+    def can_construct_buildings(self) -> StardewRule:
+        return self.logic.region.can_reach(Region.carpenter)
+
     @cache_self1
     def has_house(self, upgrade_level: int) -> StardewRule:
         if upgrade_level < 1:
@@ -83,7 +88,7 @@ def has_house(self, upgrade_level: int) -> StardewRule:
         if upgrade_level > 3:
             return False_()
 
-        carpenter_rule = self.logic.received(Event.can_construct_buildings)
+        carpenter_rule = self.logic.building.can_construct_buildings
         if self.options.building_progression & BuildingProgression.option_progressive:
             return carpenter_rule & self.logic.received(f"Progressive House", upgrade_level)
 
diff --git a/worlds/stardew_valley/logic/money_logic.py b/worlds/stardew_valley/logic/money_logic.py
index 73c5291af082..85370273c987 100644
--- a/worlds/stardew_valley/logic/money_logic.py
+++ b/worlds/stardew_valley/logic/money_logic.py
@@ -1,3 +1,4 @@
+import typing
 from typing import Union
 
 from Utils import cache_self1
@@ -11,10 +12,14 @@
 from ..data.shop import ShopSource
 from ..options import SpecialOrderLocations
 from ..stardew_rule import StardewRule, True_, HasProgressionPercent, False_, true_
-from ..strings.ap_names.event_names import Event
 from ..strings.currency_names import Currency
 from ..strings.region_names import Region, LogicRegion
 
+if typing.TYPE_CHECKING:
+    from .shipping_logic import ShippingLogicMixin
+
+    assert ShippingLogicMixin
+
 qi_gem_rewards = ("100 Qi Gems", "50 Qi Gems", "40 Qi Gems", "35 Qi Gems", "25 Qi Gems",
                   "20 Qi Gems", "15 Qi Gems", "10 Qi Gems")
 
@@ -26,7 +31,7 @@ def __init__(self, *args, **kwargs):
 
 
 class MoneyLogic(BaseLogic[Union[RegionLogicMixin, MoneyLogicMixin, TimeLogicMixin, RegionLogicMixin, ReceivedLogicMixin, HasLogicMixin, SeasonLogicMixin,
-GrindLogicMixin]]):
+GrindLogicMixin, 'ShippingLogicMixin']]):
 
     @cache_self1
     def can_have_earned_total(self, amount: int) -> StardewRule:
@@ -37,7 +42,7 @@ def can_have_earned_total(self, amount: int) -> StardewRule:
         willy_rule = self.logic.region.can_reach_all((Region.fish_shop, LogicRegion.fishing))
         clint_rule = self.logic.region.can_reach_all((Region.blacksmith, Region.mines_floor_5))
         robin_rule = self.logic.region.can_reach_all((Region.carpenter, Region.secret_woods))
-        shipping_rule = self.logic.received(Event.can_ship_items)
+        shipping_rule = self.logic.shipping.can_use_shipping_bin
 
         if amount < 2000:
             selling_any_rule = pierre_rule | willy_rule | clint_rule | robin_rule | shipping_rule
@@ -50,7 +55,7 @@ def can_have_earned_total(self, amount: int) -> StardewRule:
         if amount < 10000:
             return shipping_rule
 
-        seed_rules = self.logic.received(Event.can_shop_at_pierre)
+        seed_rules = self.logic.region.can_reach(Region.pierre_store)
         if amount < 40000:
             return shipping_rule & seed_rules
 
diff --git a/worlds/stardew_valley/logic/shipping_logic.py b/worlds/stardew_valley/logic/shipping_logic.py
index 8d545e219627..e9f2258172e6 100644
--- a/worlds/stardew_valley/logic/shipping_logic.py
+++ b/worlds/stardew_valley/logic/shipping_logic.py
@@ -11,7 +11,6 @@
 from ..options import ExcludeGingerIsland, Shipsanity
 from ..options import SpecialOrderLocations
 from ..stardew_rule import StardewRule
-from ..strings.ap_names.event_names import Event
 from ..strings.building_names import Building
 
 
@@ -29,7 +28,7 @@ def can_use_shipping_bin(self) -> StardewRule:
 
     @cache_self1
     def can_ship(self, item: str) -> StardewRule:
-        return self.logic.received(Event.can_ship_items) & self.logic.has(item)
+        return self.logic.shipping.can_use_shipping_bin & self.logic.has(item)
 
     def can_ship_everything(self) -> StardewRule:
         shipsanity_prefix = "Shipsanity: "
@@ -49,7 +48,7 @@ def can_ship_everything(self) -> StardewRule:
 
     def can_ship_everything_in_slot(self, all_location_names_in_slot: List[str]) -> StardewRule:
         if self.options.shipsanity == Shipsanity.option_none:
-            return self.can_ship_everything()
+            return self.logic.shipping.can_ship_everything()
 
         rules = [self.logic.building.has_building(Building.shipping_bin)]
 
diff --git a/worlds/stardew_valley/logic/special_order_logic.py b/worlds/stardew_valley/logic/special_order_logic.py
index 65497df477b8..8bcd78d7d26e 100644
--- a/worlds/stardew_valley/logic/special_order_logic.py
+++ b/worlds/stardew_valley/logic/special_order_logic.py
@@ -21,7 +21,6 @@
 from ..content.vanilla.qi_board import qi_board_content_pack
 from ..stardew_rule import StardewRule, Has, false_
 from ..strings.animal_product_names import AnimalProduct
-from ..strings.ap_names.event_names import Event
 from ..strings.ap_names.transport_names import Transportation
 from ..strings.artisan_good_names import ArtisanGood
 from ..strings.crop_names import Vegetable, Fruit
@@ -61,7 +60,7 @@ def initialize_rules(self):
             SpecialOrder.gifts_for_george: self.logic.season.has(Season.spring) & self.logic.has(Forageable.leek),
             SpecialOrder.fragments_of_the_past: self.logic.monster.can_kill(Monster.skeleton),
             SpecialOrder.gus_famous_omelet: self.logic.has(AnimalProduct.any_egg),
-            SpecialOrder.crop_order: self.logic.ability.can_farm_perfectly() & self.logic.received(Event.can_ship_items),
+            SpecialOrder.crop_order: self.logic.ability.can_farm_perfectly() & self.logic.shipping.can_use_shipping_bin,
             SpecialOrder.community_cleanup: self.logic.skill.can_crab_pot,
             SpecialOrder.the_strong_stuff: self.logic.has(ArtisanGood.specific_juice(Vegetable.potato)),
             SpecialOrder.pierres_prime_produce: self.logic.ability.can_farm_perfectly(),
@@ -94,12 +93,12 @@ def initialize_rules(self):
             self.update_rules({
                 SpecialOrder.qis_crop: self.logic.ability.can_farm_perfectly() & self.logic.region.can_reach(Region.greenhouse) &
                                        self.logic.region.can_reach(Region.island_west) & self.logic.skill.has_total_level(50) &
-                                       self.logic.has(Machine.seed_maker) & self.logic.received(Event.can_ship_items),
+                                       self.logic.has(Machine.seed_maker) & self.logic.shipping.can_use_shipping_bin,
                 SpecialOrder.lets_play_a_game: self.logic.arcade.has_junimo_kart_max_level(),
                 SpecialOrder.four_precious_stones: self.logic.time.has_lived_max_months & self.logic.has("Prismatic Shard") &
                                                    self.logic.ability.can_mine_perfectly_in_the_skull_cavern(),
                 SpecialOrder.qis_hungry_challenge: self.logic.ability.can_mine_perfectly_in_the_skull_cavern(),
-                SpecialOrder.qis_cuisine: self.logic.cooking.can_cook() & self.logic.received(Event.can_ship_items) &
+                SpecialOrder.qis_cuisine: self.logic.cooking.can_cook() & self.logic.shipping.can_use_shipping_bin &
                                           (self.logic.money.can_spend_at(Region.saloon, 205000) | self.logic.money.can_spend_at(Region.pierre_store, 170000)),
                 SpecialOrder.qis_kindness: self.logic.relationship.can_give_loved_gifts_to_everyone(),
                 SpecialOrder.extended_family: self.logic.ability.can_fish_perfectly() & self.logic.has(Fish.angler) & self.logic.has(Fish.glacierfish) &
diff --git a/worlds/stardew_valley/rules.py b/worlds/stardew_valley/rules.py
index eda2d4377e09..e7107e89f948 100644
--- a/worlds/stardew_valley/rules.py
+++ b/worlds/stardew_valley/rules.py
@@ -27,7 +27,6 @@
 from .stardew_rule.rule_explain import explain
 from .strings.ap_names.ap_option_names import OptionName
 from .strings.ap_names.community_upgrade_names import CommunityUpgrade
-from .strings.ap_names.event_names import Event
 from .strings.ap_names.mods.mod_items import SVEQuestItem, SVERunes
 from .strings.ap_names.transport_names import Transportation
 from .strings.artisan_good_names import ArtisanGood
@@ -251,7 +250,8 @@ def set_entrance_rules(logic: StardewLogic, multiworld, player, world_options: S
     set_entrance_rule(multiworld, player, Entrance.enter_witch_warp_cave, logic.quest.has_dark_talisman() | (logic.mod.magic.can_blink()))
     set_entrance_rule(multiworld, player, Entrance.enter_witch_hut, (logic.has(ArtisanGood.void_mayonnaise) | logic.mod.magic.can_blink()))
     set_entrance_rule(multiworld, player, Entrance.enter_mutant_bug_lair,
-                      (logic.received(Event.start_dark_talisman_quest) & logic.relationship.can_meet(NPC.krobus)) | logic.mod.magic.can_blink())
+                      (logic.wallet.has_rusty_key() & logic.region.can_reach(Region.railroad) & logic.relationship.can_meet(
+                          NPC.krobus)) | logic.mod.magic.can_blink())
     set_entrance_rule(multiworld, player, Entrance.enter_casino, logic.quest.has_club_card())
 
     set_bedroom_entrance_rules(logic, multiworld, player, world_options)
@@ -307,8 +307,7 @@ def set_mines_floor_entrance_rules(logic, multiworld, player):
         rule = logic.mine.has_mine_elevator_to_floor(floor - 10)
         if floor == 5 or floor == 45 or floor == 85:
             rule = rule & logic.mine.can_progress_in_the_mines_from_floor(floor)
-        entrance = multiworld.get_entrance(dig_to_mines_floor(floor), player)
-        MultiWorldRules.set_rule(entrance, rule)
+        set_entrance_rule(multiworld, player, dig_to_mines_floor(floor), rule)
 
 
 def set_skull_cavern_floor_entrance_rules(logic, multiworld, player):
@@ -316,8 +315,7 @@ def set_skull_cavern_floor_entrance_rules(logic, multiworld, player):
         rule = logic.mod.elevator.has_skull_cavern_elevator_to_floor(floor - 25)
         if floor == 25 or floor == 75 or floor == 125:
             rule = rule & logic.mine.can_progress_in_the_skull_cavern_from_floor(floor)
-        entrance = multiworld.get_entrance(dig_to_skull_floor(floor), player)
-        MultiWorldRules.set_rule(entrance, rule)
+        set_entrance_rule(multiworld, player, dig_to_skull_floor(floor), rule)
 
 
 def set_blacksmith_entrance_rules(logic, multiworld, player):
@@ -346,9 +344,8 @@ def set_skill_entrance_rules(logic, multiworld, player, world_options: StardewVa
 
 
 def set_blacksmith_upgrade_rule(logic, multiworld, player, entrance_name: str, item_name: str, tool_material: str):
-    material_entrance = multiworld.get_entrance(entrance_name, player)
     upgrade_rule = logic.has(item_name) & logic.money.can_spend(tool_upgrade_prices[tool_material])
-    MultiWorldRules.set_rule(material_entrance, upgrade_rule)
+    set_entrance_rule(multiworld, player, entrance_name, upgrade_rule)
 
 
 def set_festival_entrance_rules(logic, multiworld, player):
@@ -880,25 +877,19 @@ def set_traveling_merchant_day_rules(logic: StardewLogic, multiworld: MultiWorld
 
 
 def set_arcade_machine_rules(logic: StardewLogic, multiworld: MultiWorld, player: int, world_options: StardewValleyOptions):
-    MultiWorldRules.add_rule(multiworld.get_entrance(Entrance.play_junimo_kart, player),
-                             logic.received(Wallet.skull_key))
+    play_junimo_kart_rule = logic.received(Wallet.skull_key)
+
     if world_options.arcade_machine_locations != ArcadeMachineLocations.option_full_shuffling:
+        set_entrance_rule(multiworld, player, Entrance.play_junimo_kart, play_junimo_kart_rule)
         return
 
-    MultiWorldRules.add_rule(multiworld.get_entrance(Entrance.play_junimo_kart, player),
-                             logic.has("Junimo Kart Small Buff"))
-    MultiWorldRules.add_rule(multiworld.get_entrance(Entrance.reach_junimo_kart_2, player),
-                             logic.has("Junimo Kart Medium Buff"))
-    MultiWorldRules.add_rule(multiworld.get_entrance(Entrance.reach_junimo_kart_3, player),
-                             logic.has("Junimo Kart Big Buff"))
-    MultiWorldRules.add_rule(multiworld.get_entrance(Entrance.reach_junimo_kart_4, player),
-                             logic.has("Junimo Kart Max Buff"))
-    MultiWorldRules.add_rule(multiworld.get_entrance(Entrance.play_journey_of_the_prairie_king, player),
-                             logic.has("JotPK Small Buff"))
-    MultiWorldRules.add_rule(multiworld.get_entrance(Entrance.reach_jotpk_world_2, player),
-                             logic.has("JotPK Medium Buff"))
-    MultiWorldRules.add_rule(multiworld.get_entrance(Entrance.reach_jotpk_world_3, player),
-                             logic.has("JotPK Big Buff"))
+    set_entrance_rule(multiworld, player, Entrance.play_junimo_kart, play_junimo_kart_rule & logic.has("Junimo Kart Small Buff"))
+    set_entrance_rule(multiworld, player, Entrance.reach_junimo_kart_2, logic.has("Junimo Kart Medium Buff"))
+    set_entrance_rule(multiworld, player, Entrance.reach_junimo_kart_3, logic.has("Junimo Kart Big Buff"))
+    set_entrance_rule(multiworld, player, Entrance.reach_junimo_kart_4, logic.has("Junimo Kart Max Buff"))
+    set_entrance_rule(multiworld, player, Entrance.play_journey_of_the_prairie_king, logic.has("JotPK Small Buff"))
+    set_entrance_rule(multiworld, player, Entrance.reach_jotpk_world_2, logic.has("JotPK Medium Buff"))
+    set_entrance_rule(multiworld, player, Entrance.reach_jotpk_world_3, logic.has("JotPK Big Buff"))
     MultiWorldRules.add_rule(multiworld.get_location("Journey of the Prairie King Victory", player),
                              logic.has("JotPK Max Buff"))
 
@@ -1049,6 +1040,7 @@ def set_entrance_rule(multiworld, player, entrance: str, rule: StardewRule):
         potentially_required_regions = look_for_indirect_connection(rule)
         if potentially_required_regions:
             for region in potentially_required_regions:
+                logger.debug(f"Registering indirect condition for {region} -> {entrance}")
                 multiworld.register_indirect_condition(multiworld.get_region(region, player), multiworld.get_entrance(entrance, player))
 
         MultiWorldRules.set_rule(multiworld.get_entrance(entrance, player), rule)
diff --git a/worlds/stardew_valley/stardew_rule/rule_explain.py b/worlds/stardew_valley/stardew_rule/rule_explain.py
index a9767c7b72d5..2e2b9c959d7f 100644
--- a/worlds/stardew_valley/stardew_rule/rule_explain.py
+++ b/worlds/stardew_valley/stardew_rule/rule_explain.py
@@ -4,7 +4,7 @@
 from functools import cached_property, singledispatch
 from typing import Iterable, Set, Tuple, List, Optional
 
-from BaseClasses import CollectionState
+from BaseClasses import CollectionState, Location, Entrance
 from worlds.generic.Rules import CollectionRule
 from . import StardewRule, AggregatingStardewRule, Count, Has, TotalReceived, Received, Reach, true_
 
@@ -12,10 +12,10 @@
 @dataclass
 class RuleExplanation:
     rule: StardewRule
-    state: CollectionState
+    state: CollectionState = field(repr=False, hash=False)
     expected: bool
     sub_rules: Iterable[StardewRule] = field(default_factory=list)
-    explored_rules_key: Set[Tuple[str, str]] = field(default_factory=set)
+    explored_rules_key: Set[Tuple[str, str]] = field(default_factory=set, repr=False, hash=False)
     current_rule_explored: bool = False
 
     def __post_init__(self):
@@ -38,13 +38,6 @@ def __str__(self, depth=0):
                                                       if i.result is not self.expected else i.summary(depth + 1)
                                                       for i in sorted(self.explained_sub_rules, key=lambda x: x.result))
 
-    def __repr__(self, depth=0):
-        if not self.sub_rules:
-            return self.summary(depth)
-
-        return self.summary(depth) + "\n" + "\n".join(i.__repr__(depth + 1)
-                                                      for i in sorted(self.explained_sub_rules, key=lambda x: x.result))
-
     @cached_property
     def result(self) -> bool:
         try:
@@ -134,6 +127,10 @@ def _(rule: Reach, state: CollectionState, expected: bool, explored_spots: Set[T
                 access_rules = [Reach(spot.parent_region.name, "Region", rule.player)]
             else:
                 access_rules = [spot.access_rule, Reach(spot.parent_region.name, "Region", rule.player)]
+        elif spot.access_rule == Location.access_rule:
+            # Sometime locations just don't have an access rule and all the relevant logic is in the parent region.
+            access_rules = [Reach(spot.parent_region.name, "Region", rule.player)]
+
 
     elif rule.resolution_hint == 'Entrance':
         spot = state.multiworld.get_entrance(rule.spot, rule.player)
@@ -143,6 +140,9 @@ def _(rule: Reach, state: CollectionState, expected: bool, explored_spots: Set[T
                 access_rules = [Reach(spot.parent_region.name, "Region", rule.player)]
             else:
                 access_rules = [spot.access_rule, Reach(spot.parent_region.name, "Region", rule.player)]
+        elif spot.access_rule == Entrance.access_rule:
+            # Sometime entrances just don't have an access rule and all the relevant logic is in the parent region.
+            access_rules = [Reach(spot.parent_region.name, "Region", rule.player)]
 
     else:
         spot = state.multiworld.get_region(rule.spot, rule.player)
diff --git a/worlds/stardew_valley/strings/ap_names/event_names.py b/worlds/stardew_valley/strings/ap_names/event_names.py
index 88f9715abc65..449bb6720964 100644
--- a/worlds/stardew_valley/strings/ap_names/event_names.py
+++ b/worlds/stardew_valley/strings/ap_names/event_names.py
@@ -8,10 +8,6 @@ def event(name: str):
 
 class Event:
     victory = event("Victory")
-    can_construct_buildings = event("Can Construct Buildings")
-    start_dark_talisman_quest = event("Start Dark Talisman Quest")
-    can_ship_items = event("Can Ship Items")
-    can_shop_at_pierre = event("Can Shop At Pierre's")
     spring_farming = event("Spring Farming")
     summer_farming = event("Summer Farming")
     fall_farming = event("Fall Farming")
diff --git a/worlds/stardew_valley/test/rules/TestBuildings.py b/worlds/stardew_valley/test/rules/TestBuildings.py
index 2c276d8b5cbe..cacd6ea381b6 100644
--- a/worlds/stardew_valley/test/rules/TestBuildings.py
+++ b/worlds/stardew_valley/test/rules/TestBuildings.py
@@ -23,10 +23,6 @@ def test_big_coop_blueprint(self):
         self.assertFalse(big_coop_blueprint_rule(self.multiworld.state),
                          f"Rule is {repr(self.multiworld.get_location('Big Coop Blueprint', self.player).access_rule)}")
 
-        self.multiworld.state.collect(self.create_item("Can Construct Buildings"), prevent_sweep=True)
-        self.assertFalse(big_coop_blueprint_rule(self.multiworld.state),
-                         f"Rule is {repr(self.multiworld.get_location('Big Coop Blueprint', self.player).access_rule)}")
-
         self.multiworld.state.collect(self.create_item("Progressive Coop"), prevent_sweep=False)
         self.assertTrue(big_coop_blueprint_rule(self.multiworld.state),
                         f"Rule is {repr(self.multiworld.get_location('Big Coop Blueprint', self.player).access_rule)}")
@@ -35,7 +31,6 @@ def test_deluxe_coop_blueprint(self):
         self.assertFalse(self.world.logic.region.can_reach_location("Deluxe Coop Blueprint")(self.multiworld.state))
 
         self.collect_lots_of_money()
-        self.multiworld.state.collect(self.create_item("Can Construct Buildings"), prevent_sweep=True)
         self.assertFalse(self.world.logic.region.can_reach_location("Deluxe Coop Blueprint")(self.multiworld.state))
 
         self.multiworld.state.collect(self.create_item("Progressive Coop"), prevent_sweep=True)
@@ -53,10 +48,6 @@ def test_big_shed_blueprint(self):
         self.assertFalse(big_shed_rule(self.multiworld.state),
                          f"Rule is {repr(self.multiworld.get_location('Big Shed Blueprint', self.player).access_rule)}")
 
-        self.multiworld.state.collect(self.create_item("Can Construct Buildings"), prevent_sweep=True)
-        self.assertFalse(big_shed_rule(self.multiworld.state),
-                         f"Rule is {repr(self.multiworld.get_location('Big Shed Blueprint', self.player).access_rule)}")
-
         self.multiworld.state.collect(self.create_item("Progressive Shed"), prevent_sweep=True)
         self.assertTrue(big_shed_rule(self.multiworld.state),
                         f"Rule is {repr(self.multiworld.get_location('Big Shed Blueprint', self.player).access_rule)}")

From 1454bacfddca12cf324198e27963f063dcc9c12e Mon Sep 17 00:00:00 2001
From: qwint <qwint.42@gmail.com>
Date: Fri, 29 Nov 2024 14:43:33 -0500
Subject: [PATCH 04/20] HK: better error messaging for charm plando (#3907)

---
 worlds/hk/Options.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/worlds/hk/Options.py b/worlds/hk/Options.py
index fc8eae1c0aa3..e17abbb7ae47 100644
--- a/worlds/hk/Options.py
+++ b/worlds/hk/Options.py
@@ -300,7 +300,7 @@ class PlandoCharmCosts(OptionDict):
     display_name = "Charm Notch Cost Plando"
     valid_keys = frozenset(charm_names)
     schema = Schema({
-        Optional(name): And(int, lambda n: 6 >= n >= 0) for name in charm_names
+        Optional(name): And(int, lambda n: 6 >= n >= 0, error="Charm costs must be integers in the range 0-6.") for name in charm_names
         })
 
     def get_costs(self, charm_costs: typing.List[int]) -> typing.List[int]:

From a5231a27cc1d25e55f58fb847d3148a8db346523 Mon Sep 17 00:00:00 2001
From: NewSoupVi <57900059+NewSoupVi@users.noreply.github.com>
Date: Fri, 29 Nov 2024 20:45:10 +0100
Subject: [PATCH 05/20] Yacht Dice: Mark YachtWeights.py as
 "linguist-generated" (#3898)

This means its diff will be collapsed by default on PRs that change it, because it is an "auto generated" file that does not need to be looked at by reviewers
---
 .gitattributes | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitattributes b/.gitattributes
index 537a05f68b67..5ab537933405 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1 +1,2 @@
 worlds/blasphemous/region_data.py linguist-generated=true
+worlds/yachtdice/YachtWeights.py linguist-generated=true

From b605fb10323c8d1ace0465ece41db2b0eb2d0b2e Mon Sep 17 00:00:00 2001
From: NewSoupVi <57900059+NewSoupVi@users.noreply.github.com>
Date: Fri, 29 Nov 2024 20:45:44 +0100
Subject: [PATCH 06/20] The Witness: Make Elevators Come To You an OptionSet
 (#4000)

* Split elevators come to you

* .

* unit test

* mypy stuff

* Fine. I'll fix the fcking commented out code. Happy?

* ruff

* """""Backwards compatibility"""""

* ruff

* make it look better

* #

* fix presets

* fix a unit test

* Make that explicit in the code

* Improve description
---
 .../Door_Shuffle/Elevators_Come_To_You.txt    | 11 ---
 worlds/witness/data/utils.py                  |  4 --
 worlds/witness/options.py                     | 42 ++++++++++--
 worlds/witness/player_logic.py                | 26 ++++++-
 worlds/witness/presets.py                     |  9 ++-
 worlds/witness/test/test_auto_elevators.py    | 68 +++++++------------
 .../witness/test/test_roll_other_options.py   |  3 +-
 7 files changed, 94 insertions(+), 69 deletions(-)
 delete mode 100644 worlds/witness/data/settings/Door_Shuffle/Elevators_Come_To_You.txt

diff --git a/worlds/witness/data/settings/Door_Shuffle/Elevators_Come_To_You.txt b/worlds/witness/data/settings/Door_Shuffle/Elevators_Come_To_You.txt
deleted file mode 100644
index 78d245f9f0b5..000000000000
--- a/worlds/witness/data/settings/Door_Shuffle/Elevators_Come_To_You.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-New Connections:
-Quarry - Quarry Elevator - TrueOneWay
-Outside Quarry - Quarry Elevator - TrueOneWay
-Outside Bunker - Bunker Elevator - TrueOneWay
-Outside Swamp - Swamp Long Bridge - TrueOneWay
-Swamp Near Boat - Swamp Long Bridge - TrueOneWay
-Town Red Rooftop - Town Maze Rooftop - TrueOneWay
-
-
-Requirement Changes:
-0x035DE - 0x17E2B - True
\ No newline at end of file
diff --git a/worlds/witness/data/utils.py b/worlds/witness/data/utils.py
index 737daff70fae..190c00dc283b 100644
--- a/worlds/witness/data/utils.py
+++ b/worlds/witness/data/utils.py
@@ -204,10 +204,6 @@ def get_caves_except_path_to_challenge_exclusion_list() -> List[str]:
     return get_adjustment_file("settings/Exclusions/Caves_Except_Path_To_Challenge.txt")
 
 
-def get_elevators_come_to_you() -> List[str]:
-    return get_adjustment_file("settings/Door_Shuffle/Elevators_Come_To_You.txt")
-
-
 def get_entity_hunt() -> List[str]:
     return get_adjustment_file("settings/Entity_Hunt.txt")
 
diff --git a/worlds/witness/options.py b/worlds/witness/options.py
index bb935388e3c7..b5c15e242f10 100644
--- a/worlds/witness/options.py
+++ b/worlds/witness/options.py
@@ -2,7 +2,18 @@
 
 from schema import And, Schema
 
-from Options import Choice, DefaultOnToggle, OptionDict, OptionGroup, PerGameCommonOptions, Range, Toggle, Visibility
+from Options import (
+    Choice,
+    DefaultOnToggle,
+    OptionDict,
+    OptionError,
+    OptionGroup,
+    OptionSet,
+    PerGameCommonOptions,
+    Range,
+    Toggle,
+    Visibility,
+)
 
 from .data import static_logic as static_witness_logic
 from .data.item_definition_classes import ItemCategory, WeightedItemDefinition
@@ -294,12 +305,33 @@ class ChallengeLasers(Range):
     default = 11
 
 
-class ElevatorsComeToYou(Toggle):
+class ElevatorsComeToYou(OptionSet):
     """
-    If on, the Quarry Elevator, Bunker Elevator and Swamp Long Bridge will "come to you" if you approach them.
-    This does actually affect logic as it allows unintended backwards / early access into these areas.
+    In vanilla, some bridges/elevators come to you if you walk up to them when they are not currently there.
+    However, there are some that don't. Notably, this prevents Quarry Elevator from being a logical access method into Quarry, because you can send it away without riding ot and then permanently be locked out of using it.
+
+    This option allows you to change specific elevators/bridges to "come to you" as well.
+
+    - Quarry Elevator: Makes the Quarry Elevator come down when you approach it from lower Quarry and back up when you approach it from above
+    - Swamp Long Bridge: Rotates the side you approach it from towards you, but also rotates the other side away
+    - Bunker Elevator: Makes the Bunker Elevator come to any floor that you approach it from, meaning it can be accessed from the roof immediately
     """
-    display_name = "All Bridges & Elevators come to you"
+
+    # Used to be a toggle
+    @classmethod
+    def from_text(cls, text: str):
+        if text.lower() in {"off", "0", "false", "none", "null", "no"}:
+            raise OptionError('elevators_come_to_you is an OptionSet now. The equivalent of "false" is {}')
+        if text.lower() in {"on", "1", "true", "yes"}:
+            raise OptionError(
+                f'elevators_come_to_you is an OptionSet now. The equivalent of "true" is {set(cls.valid_keys)}'
+            )
+        return super().from_text(text)
+
+    display_name = "Elevators come to you"
+
+    valid_keys = frozenset({"Quarry Elevator", "Swamp Long Bridge", "Bunker Elevator"})
+    default = frozenset({"Quarry Elevator"})
 
 
 class TrapPercentage(Range):
diff --git a/worlds/witness/player_logic.py b/worlds/witness/player_logic.py
index fd86679844a7..ec4ea066e579 100644
--- a/worlds/witness/player_logic.py
+++ b/worlds/witness/player_logic.py
@@ -34,7 +34,6 @@
     get_discard_exclusion_list,
     get_early_caves_list,
     get_early_caves_start_list,
-    get_elevators_come_to_you,
     get_entity_hunt,
     get_ep_all_individual,
     get_ep_easy,
@@ -626,8 +625,29 @@ def make_options_adjustments(self, world: "WitnessWorld") -> None:
         if world.options.early_caves == "add_to_pool" and not remote_doors:
             adjustment_linesets_in_order.append(get_early_caves_list())
 
-        if world.options.elevators_come_to_you:
-            adjustment_linesets_in_order.append(get_elevators_come_to_you())
+        if "Quarry Elevator" in world.options.elevators_come_to_you:
+            adjustment_linesets_in_order.append([
+                "New Connections:",
+                "Quarry - Quarry Elevator - TrueOneWay",
+                "Outside Quarry - Quarry Elevator - TrueOneWay",
+            ])
+        if "Bunker Elevator" in world.options.elevators_come_to_you:
+            adjustment_linesets_in_order.append([
+                "New Connections:",
+                "Outside Bunker - Bunker Elevator - TrueOneWay",
+            ])
+        if "Swamp Long Bridge" in world.options.elevators_come_to_you:
+            adjustment_linesets_in_order.append([
+                "New Connections:",
+                "Outside Swamp - Swamp Long Bridge - TrueOneWay",
+                "Swamp Near Boat - Swamp Long Bridge - TrueOneWay",
+                "Requirement Changes:",
+                "0x035DE - 0x17E2B - True",  # Swamp Purple Sand Bottom EP
+            ])
+        # if "Town Maze Rooftop Bridge" in world.options.elevators_come_to_you:
+        #     adjustment_linesets_in_order.append([
+        #         "New Connections:"
+        #         "Town Red Rooftop - Town Maze Rooftop - TrueOneWay"
 
         if world.options.victory_condition == "panel_hunt":
             adjustment_linesets_in_order.append(get_entity_hunt())
diff --git a/worlds/witness/presets.py b/worlds/witness/presets.py
index 8993048065f4..687d74f771cb 100644
--- a/worlds/witness/presets.py
+++ b/worlds/witness/presets.py
@@ -35,7 +35,8 @@
         "challenge_lasers": 11,
 
         "early_caves": EarlyCaves.option_off,
-        "elevators_come_to_you": False,
+
+        "elevators_come_to_you": ElevatorsComeToYou.default,
 
         "trap_percentage": TrapPercentage.default,
         "puzzle_skip_amount": PuzzleSkipAmount.default,
@@ -73,7 +74,8 @@
         "challenge_lasers": 9,
 
         "early_caves": EarlyCaves.option_off,
-        "elevators_come_to_you": False,
+
+        "elevators_come_to_you": ElevatorsComeToYou.default,
 
         "trap_percentage": TrapPercentage.default,
         "puzzle_skip_amount": 15,
@@ -111,7 +113,8 @@
         "challenge_lasers": 9,
 
         "early_caves": EarlyCaves.option_off,
-        "elevators_come_to_you": True,
+
+        "elevators_come_to_you": ElevatorsComeToYou.valid_keys,
 
         "trap_percentage": TrapPercentage.default,
         "puzzle_skip_amount": 15,
diff --git a/worlds/witness/test/test_auto_elevators.py b/worlds/witness/test/test_auto_elevators.py
index 16b1b5a56d37..f91943e85577 100644
--- a/worlds/witness/test/test_auto_elevators.py
+++ b/worlds/witness/test/test_auto_elevators.py
@@ -1,49 +1,25 @@
-from ..test import WitnessMultiworldTestBase, WitnessTestBase
-
-
-class TestElevatorsComeToYou(WitnessTestBase):
-    options = {
-        "elevators_come_to_you": True,
-        "shuffle_doors": "mixed",
-        "shuffle_symbols": False,
-    }
-
-    def test_bunker_laser(self) -> None:
-        """
-        In elevators_come_to_you, Bunker can be entered from the back.
-        This means that you can access the laser with just Bunker Elevator Control (Panel).
-        It also means that you can, for example, access UV Room with the Control and the Elevator Room Entry Door.
-        """
-
-        self.assertFalse(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", self.player))
-
-        self.collect_by_name("Bunker Elevator Control (Panel)")
-
-        self.assertTrue(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", self.player))
-        self.assertFalse(self.multiworld.state.can_reach("Bunker UV Room 2", "Location", self.player))
-
-        self.collect_by_name("Bunker Elevator Room Entry (Door)")
-        self.collect_by_name("Bunker Drop-Down Door Controls (Panel)")
-
-        self.assertTrue(self.multiworld.state.can_reach("Bunker UV Room 2", "Location", self.player))
+from ..test import WitnessMultiworldTestBase
 
 
 class TestElevatorsComeToYouBleed(WitnessMultiworldTestBase):
     options_per_world = [
         {
-            "elevators_come_to_you": False,
+            "elevators_come_to_you": {},
         },
         {
-            "elevators_come_to_you": True,
+            "elevators_come_to_you": {"Quarry Elevator", "Swamp Long Bridge", "Bunker Elevator"},
         },
         {
-            "elevators_come_to_you": False,
+            "elevators_come_to_you": {}
         },
     ]
 
     common_options = {
         "shuffle_symbols": False,
         "shuffle_doors": "panels",
+        "shuffle_boat": True,
+        "shuffle_EPs": "individual",
+        "obelisk_keys": False,
     }
 
     def test_correct_access_per_player(self) -> None:
@@ -53,14 +29,22 @@ def test_correct_access_per_player(self) -> None:
         (This is essentially a "does connection info bleed over" test).
         """
 
-        self.assertFalse(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", 1))
-        self.assertFalse(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", 2))
-        self.assertFalse(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", 3))
-
-        self.collect_by_name(["Bunker Elevator Control (Panel)"], 1)
-        self.collect_by_name(["Bunker Elevator Control (Panel)"], 2)
-        self.collect_by_name(["Bunker Elevator Control (Panel)"], 3)
-
-        self.assertFalse(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", 1))
-        self.assertTrue(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", 2))
-        self.assertFalse(self.multiworld.state.can_reach("Bunker Laser Panel", "Location", 3))
+        combinations = [
+            ("Quarry Elevator Control (Panel)", "Quarry Boathouse Intro Left"),
+            ("Swamp Long Bridge (Panel)", "Swamp Long Bridge Side EP"),
+            ("Bunker Elevator Control (Panel)", "Bunker Laser Panel"),
+        ]
+
+        for item, location in combinations:
+            with self.subTest(f"Test that {item} only locks {location} for player 2"):
+                self.assertFalse(self.multiworld.state.can_reach_location(location, 1))
+                self.assertFalse(self.multiworld.state.can_reach_location(location, 2))
+                self.assertFalse(self.multiworld.state.can_reach_location(location, 3))
+
+                self.collect_by_name(item, 1)
+                self.collect_by_name(item, 2)
+                self.collect_by_name(item, 3)
+
+                self.assertFalse(self.multiworld.state.can_reach_location(location, 1))
+                self.assertTrue(self.multiworld.state.can_reach_location(location, 2))
+                self.assertFalse(self.multiworld.state.can_reach_location(location, 3))
diff --git a/worlds/witness/test/test_roll_other_options.py b/worlds/witness/test/test_roll_other_options.py
index 7473716e06e6..0429b097eac3 100644
--- a/worlds/witness/test/test_roll_other_options.py
+++ b/worlds/witness/test/test_roll_other_options.py
@@ -1,3 +1,4 @@
+from ..options import ElevatorsComeToYou
 from ..test import WitnessTestBase
 
 # These are just some random options combinations, just to catch whether I broke anything obvious
@@ -19,7 +20,7 @@ class TestExpertNonRandomizedEPs(WitnessTestBase):
 class TestVanillaAutoElevatorsPanels(WitnessTestBase):
     options = {
         "puzzle_randomization": "none",
-        "elevators_come_to_you": True,
+        "elevators_come_to_you": ElevatorsComeToYou.valid_keys - ElevatorsComeToYou.default,  # Opposite of default
         "shuffle_doors": "panels",
         "victory_condition": "mountain_box_short",
         "early_caves": True,

From 77d35b95e242fa15c60739262938d70be27fa8d7 Mon Sep 17 00:00:00 2001
From: Ehseezed <97066152+Ehseezed@users.noreply.github.com>
Date: Fri, 29 Nov 2024 13:46:12 -0600
Subject: [PATCH 07/20] Timespinner: Update AP to have parity with standalone
 options (#3805)

---
 worlds/timespinner/Items.py           |  8 ++++++--
 worlds/timespinner/Locations.py       |  4 ++--
 worlds/timespinner/LogicExtensions.py |  3 +++
 worlds/timespinner/Options.py         | 20 +++++++++++++++++---
 worlds/timespinner/__init__.py        | 10 ++++++++++
 5 files changed, 38 insertions(+), 7 deletions(-)

diff --git a/worlds/timespinner/Items.py b/worlds/timespinner/Items.py
index 45c67c254736..3beead95153b 100644
--- a/worlds/timespinner/Items.py
+++ b/worlds/timespinner/Items.py
@@ -138,7 +138,7 @@ class ItemData(NamedTuple):
     'Elevator Keycard': ItemData('Relic', 1337125, progression=True),
     'Jewelry Box': ItemData('Relic', 1337126, useful=True),
     'Goddess Brooch': ItemData('Relic', 1337127),
-    'Wyrm Brooch': ItemData('Relic', 1337128), 	
+    'Wyrm Brooch': ItemData('Relic', 1337128),
     'Greed Brooch': ItemData('Relic', 1337129),
     'Eternal Brooch': ItemData('Relic', 1337130),
     'Blue Orb': ItemData('Orb Melee', 1337131),
@@ -199,7 +199,11 @@ class ItemData(NamedTuple):
     'Chaos Trap': ItemData('Trap', 1337186, 0, trap=True),
     'Neurotoxin Trap': ItemData('Trap', 1337187, 0, trap=True),
     'Bee Trap': ItemData('Trap', 1337188, 0, trap=True),
-    # 1337189 - 1337248 Reserved
+    'Laser Access A': ItemData('Relic', 1337189, progression=True),
+    'Laser Access I': ItemData('Relic', 1337191, progression=True),
+    'Laser Access M': ItemData('Relic', 1337192, progression=True),
+    'Throw Stun Trap': ItemData('Trap', 1337193, 0, trap=True),
+    # 1337194 - 1337248 Reserved
     'Max Sand': ItemData('Stat', 1337249, 14)
 }
 
diff --git a/worlds/timespinner/Locations.py b/worlds/timespinner/Locations.py
index 2423e06bb010..93ac6ccb98c7 100644
--- a/worlds/timespinner/Locations.py
+++ b/worlds/timespinner/Locations.py
@@ -71,8 +71,8 @@ def get_location_datas(player: Optional[int], options: Optional[TimespinnerOptio
         LocationData('Skeleton Shaft', 'Sealed Caves (Xarion): Skeleton',  1337044),
         LocationData('Sealed Caves (Xarion)', 'Sealed Caves (Xarion): Shroom jump room',  1337045, logic.has_timestop),
         LocationData('Sealed Caves (Xarion)', 'Sealed Caves (Xarion): Double shroom room',  1337046),
-        LocationData('Sealed Caves (Xarion)', 'Sealed Caves (Xarion): Mini jackpot room',  1337047, logic.has_forwarddash_doublejump),
-        LocationData('Sealed Caves (Xarion)', 'Sealed Caves (Xarion): Below mini jackpot room',  1337048),
+        LocationData('Sealed Caves (Xarion)', 'Sealed Caves (Xarion): Jacksquat room',  1337047, logic.has_forwarddash_doublejump),
+        LocationData('Sealed Caves (Xarion)', 'Sealed Caves (Xarion): Below Jacksquat room',  1337048),
         LocationData('Sealed Caves (Xarion)', 'Sealed Caves (Xarion): Secret room',  1337049, logic.can_break_walls),
         LocationData('Sealed Caves (Xarion)', 'Sealed Caves (Xarion): Bottom left room',  1337050),
         LocationData('Sealed Caves (Xarion)', 'Sealed Caves (Xarion): Last chance before Xarion',  1337051, logic.has_doublejump),
diff --git a/worlds/timespinner/LogicExtensions.py b/worlds/timespinner/LogicExtensions.py
index 6c9cb3f684a0..2a0a358737f7 100644
--- a/worlds/timespinner/LogicExtensions.py
+++ b/worlds/timespinner/LogicExtensions.py
@@ -22,6 +22,7 @@ def __init__(self, player: int, options: Optional[TimespinnerOptions],
         self.flag_specific_keycards = bool(options and options.specific_keycards)
         self.flag_eye_spy = bool(options and options.eye_spy)
         self.flag_unchained_keys = bool(options and options.unchained_keys)
+        self.flag_prism_break = bool(options and options.prism_break)
 
         if precalculated_weights:
             if self.flag_unchained_keys:
@@ -92,6 +93,8 @@ def can_break_walls(self, state: CollectionState) -> bool:
             return True
 
     def can_kill_all_3_bosses(self, state: CollectionState) -> bool:
+        if self.flag_prism_break:
+            return state.has_all({'Laser Access M', 'Laser Access I', 'Laser Access A'}, self.player)
         return state.has_all({'Killed Maw', 'Killed Twins', 'Killed Aelana'}, self.player)
 
     def has_teleport(self, state: CollectionState) -> bool:
diff --git a/worlds/timespinner/Options.py b/worlds/timespinner/Options.py
index c06dd36797fd..72f2d8b35abf 100644
--- a/worlds/timespinner/Options.py
+++ b/worlds/timespinner/Options.py
@@ -180,12 +180,19 @@ class DamageRandoOverrides(OptionDict):
     }
 
 class HpCap(Range):
-    "Sets the number that Lunais's HP maxes out at."
+    """Sets the number that Lunais's HP maxes out at."""
     display_name = "HP Cap"
     range_start = 1
     range_end = 999
     default = 999
 
+class AuraCap(Range):
+    """Sets the maximum Aura Lunais is allowed to have. Level 1 is 80. Djinn Inferno costs 45."""
+    display_name = "Aura Cap"
+    range_start = 45
+    range_end = 999
+    default = 999
+
 class LevelCap(Range):
     """Sets the max level Lunais can achieve."""
     display_name = "Level Cap"
@@ -359,13 +366,18 @@ class TrapChance(Range):
 class Traps(OptionList):
     """List of traps that may be in the item pool to find"""
     display_name = "Traps Types"
-    valid_keys = { "Meteor Sparrow Trap", "Poison Trap", "Chaos Trap", "Neurotoxin Trap", "Bee Trap" }
-    default = [ "Meteor Sparrow Trap", "Poison Trap", "Chaos Trap", "Neurotoxin Trap", "Bee Trap" ]
+    valid_keys = { "Meteor Sparrow Trap", "Poison Trap", "Chaos Trap", "Neurotoxin Trap", "Bee Trap", "Throw Stun Trap" }
+    default = [ "Meteor Sparrow Trap", "Poison Trap", "Chaos Trap", "Neurotoxin Trap", "Bee Trap", "Throw Stun Trap" ]
 
 class PresentAccessWithWheelAndSpindle(Toggle):
     """When inverted, allows using the refugee camp warp when both the Timespinner Wheel and Spindle is acquired."""
     display_name = "Back to the future"
 
+class PrismBreak(Toggle):
+    """Adds 3 Laser Access items to the item pool to remove the lasers blocking the military hangar area
+    instead of needing to beat the Golden Idol, Aelana, and The Maw."""
+    display_name = "Prism Break"
+
 @dataclass
 class TimespinnerOptions(PerGameCommonOptions, DeathLinkMixin):
     start_with_jewelry_box: StartWithJewelryBox
@@ -383,6 +395,7 @@ class TimespinnerOptions(PerGameCommonOptions, DeathLinkMixin):
     damage_rando: DamageRando
     damage_rando_overrides: DamageRandoOverrides
     hp_cap: HpCap
+    aura_cap: AuraCap
     level_cap: LevelCap
     extra_earrings_xp: ExtraEarringsXP
     boss_healing: BossHealing
@@ -401,6 +414,7 @@ class TimespinnerOptions(PerGameCommonOptions, DeathLinkMixin):
     rising_tides_overrides: RisingTidesOverrides
     unchained_keys: UnchainedKeys
     back_to_the_future: PresentAccessWithWheelAndSpindle
+    prism_break: PrismBreak
     trap_chance: TrapChance
     traps: Traps
 
diff --git a/worlds/timespinner/__init__.py b/worlds/timespinner/__init__.py
index 72903bd5ffea..a2a5c7ce9c78 100644
--- a/worlds/timespinner/__init__.py
+++ b/worlds/timespinner/__init__.py
@@ -102,6 +102,7 @@ def fill_slot_data(self) -> Dict[str, object]:
             "DamageRando": self.options.damage_rando.value,
             "DamageRandoOverrides": self.options.damage_rando_overrides.value,
             "HpCap": self.options.hp_cap.value,
+            "AuraCap": self.options.aura_cap.value,
             "LevelCap": self.options.level_cap.value,
             "ExtraEarringsXP": self.options.extra_earrings_xp.value,
             "BossHealing": self.options.boss_healing.value,
@@ -119,6 +120,7 @@ def fill_slot_data(self) -> Dict[str, object]:
             "RisingTides": self.options.rising_tides.value,
             "UnchainedKeys": self.options.unchained_keys.value,
             "PresentAccessWithWheelAndSpindle": self.options.back_to_the_future.value,
+            "PrismBreak": self.options.prism_break.value,
             "Traps": self.options.traps.value,
             "DeathLink": self.options.death_link.value,
             "StinkyMaw": True,
@@ -224,6 +226,9 @@ def create_item(self, name: str) -> Item:
         elif name in {"Timeworn Warp Beacon", "Modern Warp Beacon", "Mysterious Warp Beacon"} \
                 and not self.options.unchained_keys:
             item.classification = ItemClassification.filler
+        elif name in {"Laser Access A", "Laser Access I", "Laser Access M"} \
+                and not self.options.prism_break:
+            item.classification = ItemClassification.filler
 
         return item
 
@@ -256,6 +261,11 @@ def get_excluded_items(self) -> Set[str]:
             excluded_items.add('Modern Warp Beacon')
             excluded_items.add('Mysterious Warp Beacon')
 
+        if not self.options.prism_break:
+            excluded_items.add('Laser Access A')
+            excluded_items.add('Laser Access I')
+            excluded_items.add('Laser Access M')
+
         for item in self.multiworld.precollected_items[self.player]:
             if item.name not in self.item_name_groups['UseItem']:
                 excluded_items.add(item.name)

From d7a0f4cb4c540c8c5045982d6e10968386ea7c39 Mon Sep 17 00:00:00 2001
From: black-sliver <59490463+black-sliver@users.noreply.github.com>
Date: Fri, 29 Nov 2024 20:49:36 +0100
Subject: [PATCH 08/20] CI: fix naming of windows build action (#4286)

---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index a5a2f52f3222..ab94326d8188 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -24,7 +24,7 @@ env:
 jobs:
   # build-release-macos: # LF volunteer
 
-  build-win-py310: # RCs will still be built and signed by hand
+  build-win: # RCs will still be built and signed by hand
     runs-on: windows-latest
     steps:
       - uses: actions/checkout@v4

From b5343a36ff4c500905b537bbf297843578b7389e Mon Sep 17 00:00:00 2001
From: Doug Hoskisson <beauxq@users.noreply.github.com>
Date: Fri, 29 Nov 2024 12:17:56 -0800
Subject: [PATCH 09/20] Core: fix settings API for removal of Python 3.8, 3.9
 (#4280)

* Core: fix settings API for removal of Python 3.8, 3.9

This is fixing 2 problems:
- The `World` class has the annotation:
  `settings: ClassVar[Optional["Group"]]`
  so `MyWorld.settings` should not raise an exception like it does for some worlds.
  With the `Optional` there, it looks like it should return `None` for the worlds that don't use it. So that's what I changed it to.

- `Group.update` had some code that required `typing.Union` instead of the Python 3.10 `|` for unions.

added unit test for this fix
added change in Zillion that I used to discover this problem and used it to test the test

* fix copy-pasted stuff

* tuple instead of set

Co-authored-by: black-sliver <59490463+black-sliver@users.noreply.github.com>

---------

Co-authored-by: black-sliver <59490463+black-sliver@users.noreply.github.com>
---
 settings.py                   | 10 ++++++++--
 test/general/test_settings.py | 16 ++++++++++++++++
 worlds/AutoWorld.py           |  5 ++++-
 worlds/zillion/__init__.py    |  2 +-
 4 files changed, 29 insertions(+), 4 deletions(-)
 create mode 100644 test/general/test_settings.py

diff --git a/settings.py b/settings.py
index 792770521459..ccd3458003c2 100644
--- a/settings.py
+++ b/settings.py
@@ -7,6 +7,7 @@
 import os.path
 import shutil
 import sys
+import types
 import typing
 import warnings
 from enum import IntEnum
@@ -162,8 +163,13 @@ def update(self, dct: Dict[str, Any]) -> None:
             else:
                 # assign value, try to upcast to type hint
                 annotation = self.get_type_hints().get(k, None)
-                candidates = [] if annotation is None else \
-                    typing.get_args(annotation) if typing.get_origin(annotation) is Union else [annotation]
+                candidates = (
+                    [] if annotation is None else (
+                        typing.get_args(annotation)
+                        if typing.get_origin(annotation) in (Union, types.UnionType)
+                        else [annotation]
+                    )
+                )
                 none_type = type(None)
                 for cls in candidates:
                     assert isinstance(cls, type), f"{self.__class__.__name__}.{k}: type {cls} not supported in settings"
diff --git a/test/general/test_settings.py b/test/general/test_settings.py
new file mode 100644
index 000000000000..165d7982b5fb
--- /dev/null
+++ b/test/general/test_settings.py
@@ -0,0 +1,16 @@
+from unittest import TestCase
+
+from settings import Group
+from worlds.AutoWorld import AutoWorldRegister
+
+
+class TestSettings(TestCase):
+    def test_settings_can_update(self) -> None:
+        """
+        Test that world settings can update.
+        """
+        for game_name, world_type in AutoWorldRegister.world_types.items():
+            with self.subTest(game=game_name):
+                if world_type.settings is not None:
+                    assert isinstance(world_type.settings, Group)
+                    world_type.settings.update({})  # a previous bug had a crash in this call to update
diff --git a/worlds/AutoWorld.py b/worlds/AutoWorld.py
index 3c4edc1b0c3b..ded8701d3b61 100644
--- a/worlds/AutoWorld.py
+++ b/worlds/AutoWorld.py
@@ -33,7 +33,10 @@ def settings(cls) -> Any:  # actual type is defined in World
         # lazy loading + caching to minimize runtime cost
         if cls.__settings is None:
             from settings import get_settings
-            cls.__settings = get_settings()[cls.settings_key]
+            try:
+                cls.__settings = get_settings()[cls.settings_key]
+            except AttributeError:
+                return None
         return cls.__settings
 
     def __new__(mcs, name: str, bases: Tuple[type, ...], dct: Dict[str, Any]) -> AutoWorldRegister:
diff --git a/worlds/zillion/__init__.py b/worlds/zillion/__init__.py
index d5e86bb33292..e689f2f55c58 100644
--- a/worlds/zillion/__init__.py
+++ b/worlds/zillion/__init__.py
@@ -47,7 +47,7 @@ class RomStart(str):
         """
 
     rom_file: RomFile = RomFile(RomFile.copy_to)
-    rom_start: typing.Union[RomStart, bool] = RomStart("retroarch")
+    rom_start: RomStart | bool = RomStart("retroarch")
 
 
 class ZillionWebWorld(WebWorld):

From 2fb59d39c93a6b5e36efe25d79c9d626b53139fe Mon Sep 17 00:00:00 2001
From: Doug Hoskisson <beauxq@users.noreply.github.com>
Date: Fri, 29 Nov 2024 12:25:01 -0800
Subject: [PATCH 10/20] Zillion: use "new" settings api and cleaning (#3903)

* Zillion: use "new" settings api and cleaning

* python 3.10 typing update

* don't separate assignments of item link players
---
 worlds/zillion/__init__.py                    | 83 ++++++++++---------
 worlds/zillion/client.py                      | 69 +++++++--------
 worlds/zillion/gen_data.py                    |  3 +-
 worlds/zillion/id_maps.py                     | 29 +++----
 worlds/zillion/logic.py                       | 13 +--
 worlds/zillion/options.py                     | 10 +--
 worlds/zillion/patch.py                       | 24 ++++--
 worlds/zillion/region.py                      | 10 ++-
 worlds/zillion/test/TestReproducibleRandom.py |  7 +-
 worlds/zillion/test/__init__.py               |  8 +-
 10 files changed, 136 insertions(+), 120 deletions(-)

diff --git a/worlds/zillion/__init__.py b/worlds/zillion/__init__.py
index e689f2f55c58..5a4e2bb48f18 100644
--- a/worlds/zillion/__init__.py
+++ b/worlds/zillion/__init__.py
@@ -3,11 +3,12 @@
 import functools
 import settings
 import threading
-import typing
-from typing import Any, Dict, List, Set, Tuple, Optional, Union
+from typing import Any, ClassVar
 import os
 import logging
 
+from typing_extensions import override
+
 from BaseClasses import ItemClassification, LocationProgressType, \
     MultiWorld, Item, CollectionState, Entrance, Tutorial
 
@@ -76,7 +77,7 @@ class ZillionWorld(World):
     options_dataclass = ZillionOptions
     options: ZillionOptions  # type: ignore
 
-    settings: typing.ClassVar[ZillionSettings]  # type: ignore
+    settings: ClassVar[ZillionSettings]  # type: ignore
     # these type: ignore are because of this issue: https://github.com/python/typing/discussions/1486
 
     topology_present = True  # indicate if world type has any meaningful layout/pathing
@@ -89,14 +90,14 @@ class ZillionWorld(World):
 
     class LogStreamInterface:
         logger: logging.Logger
-        buffer: List[str]
+        buffer: list[str]
 
         def __init__(self, logger: logging.Logger) -> None:
             self.logger = logger
             self.buffer = []
 
         def write(self, msg: str) -> None:
-            if msg.endswith('\n'):
+            if msg.endswith("\n"):
                 self.buffer.append(msg[:-1])
                 self.logger.debug("".join(self.buffer))
                 self.buffer = []
@@ -108,21 +109,21 @@ def flush(self) -> None:
 
     lsi: LogStreamInterface
 
-    id_to_zz_item: Optional[Dict[int, ZzItem]] = None
+    id_to_zz_item: dict[int, ZzItem] | None = None
     zz_system: System
-    _item_counts: "Counter[str]" = Counter()
+    _item_counts: Counter[str] = Counter()
     """
     These are the items counts that will be in the game,
     which might be different from the item counts the player asked for in options
     (if the player asked for something invalid).
     """
-    my_locations: List[ZillionLocation] = []
+    my_locations: list[ZillionLocation] = []
     """ This is kind of a cache to avoid iterating through all the multiworld locations in logic. """
     slot_data_ready: threading.Event
     """ This event is set in `generate_output` when the data is ready for `fill_slot_data` """
-    logic_cache: Union[ZillionLogicCache, None] = None
+    logic_cache: ZillionLogicCache | None = None
 
-    def __init__(self, world: MultiWorld, player: int):
+    def __init__(self, world: MultiWorld, player: int) -> None:
         super().__init__(world, player)
         self.logger = logging.getLogger("Zillion")
         self.lsi = ZillionWorld.LogStreamInterface(self.logger)
@@ -133,6 +134,7 @@ def _make_item_maps(self, start_char: Chars) -> None:
         _id_to_name, _id_to_zz_id, id_to_zz_item = make_id_to_others(start_char)
         self.id_to_zz_item = id_to_zz_item
 
+    @override
     def generate_early(self) -> None:
         zz_op, item_counts = validate(self.options)
 
@@ -150,12 +152,13 @@ def generate_early(self) -> None:
         # just in case the options changed anything (I don't think they do)
         assert self.zz_system.randomizer, "init failed"
         for zz_name in self.zz_system.randomizer.locations:
-            if zz_name != 'main':
+            if zz_name != "main":
                 assert self.zz_system.randomizer.loc_name_2_pretty[zz_name] in self.location_name_to_id, \
                     f"{self.zz_system.randomizer.loc_name_2_pretty[zz_name]} not in location map"
 
         self._make_item_maps(zz_op.start_char)
 
+    @override
     def create_regions(self) -> None:
         assert self.zz_system.randomizer, "generate_early hasn't been called"
         assert self.id_to_zz_item, "generate_early hasn't been called"
@@ -177,23 +180,23 @@ def create_regions(self) -> None:
                 zz_loc.req.gun = 1
             assert len(self.zz_system.randomizer.get_locations(Req(gun=1, jump=1))) != 0
 
-        start = self.zz_system.randomizer.regions['start']
+        start = self.zz_system.randomizer.regions["start"]
 
-        all: Dict[str, ZillionRegion] = {}
+        all_regions: dict[str, ZillionRegion] = {}
         for here_zz_name, zz_r in self.zz_system.randomizer.regions.items():
             here_name = "Menu" if here_zz_name == "start" else zz_reg_name_to_reg_name(here_zz_name)
-            all[here_name] = ZillionRegion(zz_r, here_name, here_name, p, w)
-            self.multiworld.regions.append(all[here_name])
+            all_regions[here_name] = ZillionRegion(zz_r, here_name, here_name, p, w)
+            self.multiworld.regions.append(all_regions[here_name])
 
         limited_skill = Req(gun=3, jump=3, skill=self.zz_system.randomizer.options.skill, hp=940, red=1, floppy=126)
         queue = deque([start])
-        done: Set[str] = set()
+        done: set[str] = set()
         while len(queue):
             zz_here = queue.popleft()
             here_name = "Menu" if zz_here.name == "start" else zz_reg_name_to_reg_name(zz_here.name)
             if here_name in done:
                 continue
-            here = all[here_name]
+            here = all_regions[here_name]
 
             for zz_loc in zz_here.locations:
                 # if local gun reqs didn't place "keyword" item
@@ -217,15 +220,16 @@ def access_rule_wrapped(zz_loc_local: ZzLocation,
                     self.my_locations.append(loc)
 
             for zz_dest in zz_here.connections.keys():
-                dest_name = "Menu" if zz_dest.name == 'start' else zz_reg_name_to_reg_name(zz_dest.name)
-                dest = all[dest_name]
-                exit = Entrance(p, f"{here_name} to {dest_name}", here)
-                here.exits.append(exit)
-                exit.connect(dest)
+                dest_name = "Menu" if zz_dest.name == "start" else zz_reg_name_to_reg_name(zz_dest.name)
+                dest = all_regions[dest_name]
+                exit_ = Entrance(p, f"{here_name} to {dest_name}", here)
+                here.exits.append(exit_)
+                exit_.connect(dest)
 
                 queue.append(zz_dest)
             done.add(here.name)
 
+    @override
     def create_items(self) -> None:
         if not self.id_to_zz_item:
             self._make_item_maps("JJ")
@@ -249,14 +253,11 @@ def create_items(self) -> None:
                 self.logger.debug(f"Zillion Items: {item_name}  1")
                 self.multiworld.itempool.append(self.create_item(item_name))
 
-    def set_rules(self) -> None:
-        # logic for this game is in create_regions
-        pass
-
+    @override
     def generate_basic(self) -> None:
         assert self.zz_system.randomizer, "generate_early hasn't been called"
         # main location name is an alias
-        main_loc_name = self.zz_system.randomizer.loc_name_2_pretty[self.zz_system.randomizer.locations['main'].name]
+        main_loc_name = self.zz_system.randomizer.loc_name_2_pretty[self.zz_system.randomizer.locations["main"].name]
 
         self.multiworld.get_location(main_loc_name, self.player)\
             .place_locked_item(self.create_item("Win"))
@@ -264,22 +265,18 @@ def generate_basic(self) -> None:
             lambda state: state.has("Win", self.player)
 
     @staticmethod
-    def stage_generate_basic(multiworld: MultiWorld, *args: Any) -> None:
+    def stage_generate_basic(multiworld: MultiWorld, *args: Any) -> None:  # noqa: ANN401
         # item link pools are about to be created in main
         # JJ can't be an item link unless all the players share the same start_char
         # (The reason for this is that the JJ ZillionItem will have a different ZzItem depending
         #  on whether the start char is Apple or Champ, and the logic depends on that ZzItem.)
         for group in multiworld.groups.values():
-            # TODO: remove asserts on group when we can specify which members of TypedDict are optional
-            assert "game" in group
-            if group["game"] == "Zillion":
-                assert "item_pool" in group
+            if group["game"] == "Zillion" and "item_pool" in group:
                 item_pool = group["item_pool"]
                 to_stay: Chars = "JJ"
                 if "JJ" in item_pool:
-                    assert "players" in group
-                    group_players = group["players"]
-                    players_start_chars: List[Tuple[int, Chars]] = []
+                    group["players"] = group_players = set(group["players"])
+                    players_start_chars: list[tuple[int, Chars]] = []
                     for player in group_players:
                         z_world = multiworld.worlds[player]
                         assert isinstance(z_world, ZillionWorld)
@@ -291,17 +288,17 @@ def stage_generate_basic(multiworld: MultiWorld, *args: Any) -> None:
                     elif start_char_counts["Champ"] > start_char_counts["Apple"]:
                         to_stay = "Champ"
                     else:  # equal
-                        choices: Tuple[Chars, ...] = ("Apple", "Champ")
+                        choices: tuple[Chars, ...] = ("Apple", "Champ")
                         to_stay = multiworld.random.choice(choices)
 
                     for p, sc in players_start_chars:
                         if sc != to_stay:
                             group_players.remove(p)
-                assert "world" in group
                 group_world = group["world"]
                 assert isinstance(group_world, ZillionWorld)
                 group_world._make_item_maps(to_stay)
 
+    @override
     def post_fill(self) -> None:
         """Optional Method that is called after regular fill. Can be used to do adjustments before output generation.
         This happens before progression balancing,  so the items may not be in their final locations yet."""
@@ -317,10 +314,10 @@ def finalize_item_locations(self) -> GenData:
 
         assert self.zz_system.randomizer, "generate_early hasn't been called"
 
-        # debug_zz_loc_ids: Dict[str, int] = {}
+        # debug_zz_loc_ids: dict[str, int] = {}
         empty = zz_items[4]
         multi_item = empty  # a different patcher method differentiates empty from ap multi item
-        multi_items: Dict[str, Tuple[str, str]] = {}  # zz_loc_name to (item_name, player_name)
+        multi_items: dict[str, tuple[str, str]] = {}  # zz_loc_name to (item_name, player_name)
         for z_loc in self.multiworld.get_locations(self.player):
             assert isinstance(z_loc, ZillionLocation)
             # debug_zz_loc_ids[z_loc.zz_loc.name] = id(z_loc.zz_loc)
@@ -343,7 +340,7 @@ def finalize_item_locations(self) -> GenData:
         #     print(id_)
         # print("size:", len(debug_zz_loc_ids))
 
-        # debug_loc_to_id: Dict[str, int] = {}
+        # debug_loc_to_id: dict[str, int] = {}
         # regions = self.zz_randomizer.regions
         # for region in regions.values():
         #     for loc in region.locations:
@@ -358,10 +355,11 @@ def finalize_item_locations(self) -> GenData:
                 f"in world {self.player} didn't get an item"
             )
 
-        game_id = self.multiworld.player_name[self.player].encode() + b'\x00' + self.multiworld.seed_name[-6:].encode()
+        game_id = self.multiworld.player_name[self.player].encode() + b"\x00" + self.multiworld.seed_name[-6:].encode()
 
         return GenData(multi_items, self.zz_system.get_game(), game_id)
 
+    @override
     def generate_output(self, output_directory: str) -> None:
         """This method gets called from a threadpool, do not use multiworld.random here.
         If you need any last-second randomization, use self.random instead."""
@@ -383,6 +381,7 @@ def generate_output(self, output_directory: str) -> None:
 
         self.logger.debug(f"Zillion player {self.player} finished generate_output")
 
+    @override
     def fill_slot_data(self) -> ZillionSlotInfo:  # json of WebHostLib.models.Slot
         """Fill in the `slot_data` field in the `Connected` network package.
         This is a way the generator can give custom data to the client.
@@ -400,6 +399,7 @@ def fill_slot_data(self) -> ZillionSlotInfo:  # json of WebHostLib.models.Slot
 
     # end of ordered Main.py calls
 
+    @override
     def create_item(self, name: str) -> Item:
         """Create an item for this world type and player.
         Warning: this may be called with self.multiworld = None, for example by MultiServer"""
@@ -420,6 +420,7 @@ def create_item(self, name: str) -> Item:
         z_item = ZillionItem(name, classification, item_id, self.player, zz_item)
         return z_item
 
+    @override
     def get_filler_item_name(self) -> str:
         """Called when the item pool needs to be filled with additional items to match location count."""
         return "Empty"
diff --git a/worlds/zillion/client.py b/worlds/zillion/client.py
index 09d0565e1c5e..d629df583a81 100644
--- a/worlds/zillion/client.py
+++ b/worlds/zillion/client.py
@@ -3,7 +3,7 @@
 import io
 import pkgutil
 import platform
-from typing import Any, ClassVar, Coroutine, Dict, List, Optional, Protocol, Tuple, cast
+from typing import Any, ClassVar, Coroutine, Protocol, cast
 
 from CommonClient import CommonContext, server_loop, gui_enabled, \
     ClientCommandProcessor, logger, get_base_parser
@@ -11,6 +11,7 @@
 from Utils import async_start
 
 import colorama
+from typing_extensions import override
 
 from zilliandomizer.zri.memory import Memory, RescueInfo
 from zilliandomizer.zri import events
@@ -35,11 +36,11 @@ def _cmd_map(self) -> None:
 
 
 class ToggleCallback(Protocol):
-    def __call__(self) -> None: ...
+    def __call__(self) -> object: ...
 
 
 class SetRoomCallback(Protocol):
-    def __call__(self, rooms: List[List[int]]) -> None: ...
+    def __call__(self, rooms: list[list[int]]) -> object: ...
 
 
 class ZillionContext(CommonContext):
@@ -47,7 +48,7 @@ class ZillionContext(CommonContext):
     command_processor = ZillionCommandProcessor
     items_handling = 1  # receive items from other players
 
-    known_name: Optional[str]
+    known_name: str | None
     """ This is almost the same as `auth` except `auth` is reset to `None` when server disconnects, and this isn't. """
 
     from_game: "asyncio.Queue[events.EventFromGame]"
@@ -56,11 +57,11 @@ class ZillionContext(CommonContext):
     """ local checks watched by server """
     next_item: int
     """ index in `items_received` """
-    ap_id_to_name: Dict[int, str]
-    ap_id_to_zz_id: Dict[int, int]
+    ap_id_to_name: dict[int, str]
+    ap_id_to_zz_id: dict[int, int]
     start_char: Chars = "JJ"
-    rescues: Dict[int, RescueInfo] = {}
-    loc_mem_to_id: Dict[int, int] = {}
+    rescues: dict[int, RescueInfo] = {}
+    loc_mem_to_id: dict[int, int] = {}
     got_room_info: asyncio.Event
     """ flag for connected to server """
     got_slot_data: asyncio.Event
@@ -119,22 +120,22 @@ def reset_game_state(self) -> None:
         self.finished_game = False
         self.items_received.clear()
 
-    # override
-    def on_deathlink(self, data: Dict[str, Any]) -> None:
+    @override
+    def on_deathlink(self, data: dict[str, Any]) -> None:
         self.to_game.put_nowait(events.DeathEventToGame())
         return super().on_deathlink(data)
 
-    # override
+    @override
     async def server_auth(self, password_requested: bool = False) -> None:
         if password_requested and not self.password:
             await super().server_auth(password_requested)
         if not self.auth:
-            logger.info('waiting for connection to game...')
+            logger.info("waiting for connection to game...")
             return
         logger.info("logging in to server...")
         await self.send_connect()
 
-    # override
+    @override
     def run_gui(self) -> None:
         from kvui import GameManager
         from kivy.core.text import Label as CoreLabel
@@ -154,10 +155,10 @@ class MapPanel(Widget):
                 MAP_WIDTH: ClassVar[int] = 281
 
                 map_background: CoreImage
-                _number_textures: List[Texture] = []
-                rooms: List[List[int]] = []
+                _number_textures: list[Texture] = []
+                rooms: list[list[int]] = []
 
-                def __init__(self, **kwargs: Any) -> None:
+                def __init__(self, **kwargs: Any) -> None:  # noqa: ANN401
                     super().__init__(**kwargs)
 
                     FILE_NAME = "empty-zillion-map-row-col-labels-281.png"
@@ -183,7 +184,7 @@ def _make_numbers(self) -> None:
                         label.refresh()
                         self._number_textures.append(label.texture)
 
-                def update_map(self, *args: Any) -> None:
+                def update_map(self, *args: Any) -> None:  # noqa: ANN401
                     self.canvas.clear()
 
                     with self.canvas:
@@ -203,6 +204,7 @@ def update_map(self, *args: Any) -> None:
                                     num_texture = self._number_textures[num]
                                     Rectangle(texture=num_texture, size=num_texture.size, pos=pos)
 
+            @override
             def build(self) -> Layout:
                 container = super().build()
                 self.map_widget = ZillionManager.MapPanel(size_hint_x=None, width=ZillionManager.MapPanel.MAP_WIDTH)
@@ -216,17 +218,18 @@ def toggle_map_width(self) -> None:
                     self.map_widget.width = 0
                 self.container.do_layout()
 
-            def set_rooms(self, rooms: List[List[int]]) -> None:
+            def set_rooms(self, rooms: list[list[int]]) -> None:
                 self.map_widget.rooms = rooms
                 self.map_widget.update_map()
 
         self.ui = ZillionManager(self)
-        self.ui_toggle_map = lambda: self.ui.toggle_map_width()
-        self.ui_set_rooms = lambda rooms: self.ui.set_rooms(rooms)
+        self.ui_toggle_map = lambda: isinstance(self.ui, ZillionManager) and self.ui.toggle_map_width()
+        self.ui_set_rooms = lambda rooms: isinstance(self.ui, ZillionManager) and self.ui.set_rooms(rooms)
         run_co: Coroutine[Any, Any, None] = self.ui.async_run()
         self.ui_task = asyncio.create_task(run_co, name="UI")
 
-    def on_package(self, cmd: str, args: Dict[str, Any]) -> None:
+    @override
+    def on_package(self, cmd: str, args: dict[str, Any]) -> None:
         self.room_item_numbers_to_ui()
         if cmd == "Connected":
             logger.info("logged in to Archipelago server")
@@ -238,7 +241,7 @@ def on_package(self, cmd: str, args: Dict[str, Any]) -> None:
             if "start_char" not in slot_data:
                 logger.warning("invalid Zillion `Connected` packet, `slot_data` missing `start_char`")
                 return
-            self.start_char = slot_data['start_char']
+            self.start_char = slot_data["start_char"]
             if self.start_char not in {"Apple", "Champ", "JJ"}:
                 logger.warning("invalid Zillion `Connected` packet, "
                                f"`slot_data` `start_char` has invalid value: {self.start_char}")
@@ -259,7 +262,7 @@ def on_package(self, cmd: str, args: Dict[str, Any]) -> None:
                 self.rescues[0 if rescue_id == "0" else 1] = ri
 
             if "loc_mem_to_id" not in slot_data:
-                logger.warn("invalid Zillion `Connected` packet, `slot_data` missing `loc_mem_to_id`")
+                logger.warning("invalid Zillion `Connected` packet, `slot_data` missing `loc_mem_to_id`")
                 return
             loc_mem_to_id = slot_data["loc_mem_to_id"]
             self.loc_mem_to_id = {}
@@ -286,7 +289,7 @@ def on_package(self, cmd: str, args: Dict[str, Any]) -> None:
             if "keys" not in args:
                 logger.warning(f"invalid Retrieved packet to ZillionClient: {args}")
                 return
-            keys = cast(Dict[str, Optional[str]], args["keys"])
+            keys = cast(dict[str, str | None], args["keys"])
             doors_b64 = keys.get(f"zillion-{self.auth}-doors", None)
             if doors_b64:
                 logger.info("received door data from server")
@@ -321,9 +324,9 @@ def process_from_game_queue(self) -> None:
                 if server_id in self.missing_locations:
                     self.ap_local_count += 1
                     n_locations = len(self.missing_locations) + len(self.checked_locations) - 1  # -1 to ignore win
-                    logger.info(f'New Check: {loc_name} ({self.ap_local_count}/{n_locations})')
+                    logger.info(f"New Check: {loc_name} ({self.ap_local_count}/{n_locations})")
                     async_start(self.send_msgs([
-                        {"cmd": 'LocationChecks', "locations": [server_id]}
+                        {"cmd": "LocationChecks", "locations": [server_id]}
                     ]))
                 else:
                     # This will happen a lot in Zillion,
@@ -334,7 +337,7 @@ def process_from_game_queue(self) -> None:
             elif isinstance(event_from_game, events.WinEventFromGame):
                 if not self.finished_game:
                     async_start(self.send_msgs([
-                        {"cmd": 'LocationChecks', "locations": [loc_name_to_id["J-6 bottom far left"]]},
+                        {"cmd": "LocationChecks", "locations": [loc_name_to_id["J-6 bottom far left"]]},
                         {"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}
                     ]))
                     self.finished_game = True
@@ -362,24 +365,24 @@ def process_items_received(self) -> None:
                 ap_id = self.items_received[index].item
                 from_name = self.player_names[self.items_received[index].player]
                 # TODO: colors in this text, like sni client?
-                logger.info(f'received {self.ap_id_to_name[ap_id]} from {from_name}')
+                logger.info(f"received {self.ap_id_to_name[ap_id]} from {from_name}")
             self.to_game.put_nowait(
                 events.ItemEventToGame(zz_item_ids)
             )
             self.next_item = len(self.items_received)
 
 
-def name_seed_from_ram(data: bytes) -> Tuple[str, str]:
+def name_seed_from_ram(data: bytes) -> tuple[str, str]:
     """ returns player name, and end of seed string """
     if len(data) == 0:
         # no connection to game
         return "", "xxx"
-    null_index = data.find(b'\x00')
+    null_index = data.find(b"\x00")
     if null_index == -1:
         logger.warning(f"invalid game id in rom {repr(data)}")
         null_index = len(data)
     name = data[:null_index].decode()
-    null_index_2 = data.find(b'\x00', null_index + 1)
+    null_index_2 = data.find(b"\x00", null_index + 1)
     if null_index_2 == -1:
         null_index_2 = len(data)
     seed_name = data[null_index + 1:null_index_2].decode()
@@ -479,8 +482,8 @@ def log_no_spam(msg: str) -> None:
 
 async def main() -> None:
     parser = get_base_parser()
-    parser.add_argument('diff_file', default="", type=str, nargs="?",
-                        help='Path to a .apzl Archipelago Binary Patch file')
+    parser.add_argument("diff_file", default="", type=str, nargs="?",
+                        help="Path to a .apzl Archipelago Binary Patch file")
     # SNI parser.add_argument('--loglevel', default='info', choices=['debug', 'info', 'warning', 'error', 'critical'])
     args = parser.parse_args()
     print(args)
diff --git a/worlds/zillion/gen_data.py b/worlds/zillion/gen_data.py
index 13cbee9ced20..214073396153 100644
--- a/worlds/zillion/gen_data.py
+++ b/worlds/zillion/gen_data.py
@@ -1,6 +1,5 @@
 from dataclasses import dataclass
 import json
-from typing import Dict, Tuple
 
 from zilliandomizer.game import Game as ZzGame
 
@@ -9,7 +8,7 @@
 class GenData:
     """ data passed from generation to patcher """
 
-    multi_items: Dict[str, Tuple[str, str]]
+    multi_items: dict[str, tuple[str, str]]
     """ zz_loc_name to (item_name, player_name) """
     zz_game: ZzGame
     game_id: bytes
diff --git a/worlds/zillion/id_maps.py b/worlds/zillion/id_maps.py
index 32d71fc79b30..25762f99cd6b 100644
--- a/worlds/zillion/id_maps.py
+++ b/worlds/zillion/id_maps.py
@@ -1,5 +1,6 @@
 from collections import defaultdict
-from typing import Dict, Iterable, Mapping, Tuple, TypedDict
+from collections.abc import Iterable, Mapping
+from typing import TypedDict
 
 from zilliandomizer.logic_components.items import (
     Item as ZzItem,
@@ -40,13 +41,13 @@
 _zz_empty = zz_item_name_to_zz_item["empty"]
 
 
-def make_id_to_others(start_char: Chars) -> Tuple[
-    Dict[int, str], Dict[int, int], Dict[int, ZzItem]
+def make_id_to_others(start_char: Chars) -> tuple[
+    dict[int, str], dict[int, int], dict[int, ZzItem]
 ]:
     """ returns id_to_name, id_to_zz_id, id_to_zz_item """
-    id_to_name: Dict[int, str] = {}
-    id_to_zz_id: Dict[int, int] = {}
-    id_to_zz_item: Dict[int, ZzItem] = {}
+    id_to_name: dict[int, str] = {}
+    id_to_zz_id: dict[int, int] = {}
+    id_to_zz_item: dict[int, ZzItem] = {}
 
     if start_char == "JJ":
         name_to_zz_item = {
@@ -91,14 +92,14 @@ def make_room_name(row: int, col: int) -> str:
     return f"{chr(ord('A') + row - 1)}-{col + 1}"
 
 
-loc_name_to_id: Dict[str, int] = {
+loc_name_to_id: dict[str, int] = {
     name: id_ + base_id
     for name, id_ in pretty_loc_name_to_id.items()
 }
 
 
 def zz_reg_name_to_reg_name(zz_reg_name: str) -> str:
-    if zz_reg_name[0] == 'r' and zz_reg_name[3] == 'c':
+    if zz_reg_name[0] == "r" and zz_reg_name[3] == "c":
         row, col = parse_reg_name(zz_reg_name)
         end = zz_reg_name[5:]
         return f"{make_room_name(row, col)} {end.upper()}"
@@ -113,17 +114,17 @@ class ClientRescue(TypedDict):
 
 class ZillionSlotInfo(TypedDict):
     start_char: Chars
-    rescues: Dict[str, ClientRescue]
-    loc_mem_to_id: Dict[int, int]
+    rescues: dict[str, ClientRescue]
+    loc_mem_to_id: dict[int, int]
     """ memory location of canister to Archipelago location id number """
 
 
 def get_slot_info(regions: Iterable[RegionData],
                   start_char: Chars,
                   loc_name_to_pretty: Mapping[str, str]) -> ZillionSlotInfo:
-    items_placed_in_map_index: Dict[int, int] = defaultdict(int)
-    rescue_locations: Dict[int, RescueInfo] = {}
-    loc_memory_to_loc_id: Dict[int, int] = {}
+    items_placed_in_map_index: dict[int, int] = defaultdict(int)
+    rescue_locations: dict[int, RescueInfo] = {}
+    loc_memory_to_loc_id: dict[int, int] = {}
     for region in regions:
         for loc in region.locations:
             assert loc.item, ("There should be an item placed in every location before "
@@ -142,7 +143,7 @@ def get_slot_info(regions: Iterable[RegionData],
                 loc_memory_to_loc_id[loc_memory] = pretty_loc_name_to_id[loc_name_to_pretty[loc.name]]
                 items_placed_in_map_index[map_index] += 1
 
-    rescues: Dict[str, ClientRescue] = {}
+    rescues: dict[str, ClientRescue] = {}
     for i in (0, 1):
         if i in rescue_locations:
             ri = rescue_locations[i]
diff --git a/worlds/zillion/logic.py b/worlds/zillion/logic.py
index a14910a200e5..f3d1814a9e9b 100644
--- a/worlds/zillion/logic.py
+++ b/worlds/zillion/logic.py
@@ -1,4 +1,5 @@
-from typing import Dict, FrozenSet, Mapping, Tuple, List, Counter as _Counter
+from collections import Counter
+from collections.abc import Mapping
 
 from BaseClasses import CollectionState
 
@@ -35,7 +36,7 @@ def set_randomizer_locs(cs: CollectionState, p: int, zz_r: Randomizer) -> int:
     return _hash
 
 
-def item_counts(cs: CollectionState, p: int) -> Tuple[Tuple[str, int], ...]:
+def item_counts(cs: CollectionState, p: int) -> tuple[tuple[str, int], ...]:
     """
     the zilliandomizer items that player p has collected
 
@@ -44,11 +45,11 @@ def item_counts(cs: CollectionState, p: int) -> Tuple[Tuple[str, int], ...]:
     return tuple((item_name, cs.count(item_name, p)) for item_name in item_name_to_id)
 
 
-_cache_miss: Tuple[None, FrozenSet[Location]] = (None, frozenset())
+_cache_miss: tuple[None, frozenset[Location]] = (None, frozenset())
 
 
 class ZillionLogicCache:
-    _cache: Dict[int, Tuple[_Counter[str], FrozenSet[Location]]]
+    _cache: dict[int, tuple[Counter[str], frozenset[Location]]]
     """ `{ hash: (counter_from_prog_items, accessible_zz_locations) }` """
     _player: int
     _zz_r: Randomizer
@@ -60,7 +61,7 @@ def __init__(self, player: int, zz_r: Randomizer, id_to_zz_item: Mapping[int, It
         self._zz_r = zz_r
         self._id_to_zz_item = id_to_zz_item
 
-    def cs_to_zz_locs(self, cs: CollectionState) -> FrozenSet[Location]:
+    def cs_to_zz_locs(self, cs: CollectionState) -> frozenset[Location]:
         """
         given an Archipelago `CollectionState`,
         returns frozenset of accessible zilliandomizer locations
@@ -76,7 +77,7 @@ def cs_to_zz_locs(self, cs: CollectionState) -> FrozenSet[Location]:
             return locs
 
         # print("cache miss")
-        have_items: List[Item] = []
+        have_items: list[Item] = []
         for name, count in counts:
             have_items.extend([self._id_to_zz_item[item_name_to_id[name]]] * count)
         # have_req is the result of converting AP CollectionState to zilliandomizer collection state
diff --git a/worlds/zillion/options.py b/worlds/zillion/options.py
index ec0fdb0b22e1..22a698472265 100644
--- a/worlds/zillion/options.py
+++ b/worlds/zillion/options.py
@@ -1,6 +1,6 @@
 from collections import Counter
 from dataclasses import dataclass
-from typing import ClassVar, Dict, Literal, Tuple, TypeGuard
+from typing import ClassVar, Literal, TypeGuard
 
 from Options import Choice, DefaultOnToggle, NamedRange, OptionGroup, PerGameCommonOptions, Range, Removed, Toggle
 
@@ -107,7 +107,7 @@ class ZillionStartChar(Choice):
     display_name = "start character"
     default = "random"
 
-    _name_capitalization: ClassVar[Dict[int, Chars]] = {
+    _name_capitalization: ClassVar[dict[int, Chars]] = {
         option_jj: "JJ",
         option_apple: "Apple",
         option_champ: "Champ",
@@ -263,7 +263,7 @@ class ZillionMapGen(Choice):
     option_full = 2
     default = 0
 
-    def zz_value(self) -> Literal['none', 'rooms', 'full']:
+    def zz_value(self) -> Literal["none", "rooms", "full"]:
         if self.value == ZillionMapGen.option_none:
             return "none"
         if self.value == ZillionMapGen.option_rooms:
@@ -305,7 +305,7 @@ class ZillionOptions(PerGameCommonOptions):
 ]
 
 
-def convert_item_counts(ic: "Counter[str]") -> ZzItemCounts:
+def convert_item_counts(ic: Counter[str]) -> ZzItemCounts:
     tr: ZzItemCounts = {
         ID.card: ic["ID Card"],
         ID.red: ic["Red ID Card"],
@@ -319,7 +319,7 @@ def convert_item_counts(ic: "Counter[str]") -> ZzItemCounts:
     return tr
 
 
-def validate(options: ZillionOptions) -> "Tuple[ZzOptions, Counter[str]]":
+def validate(options: ZillionOptions) -> tuple[ZzOptions, Counter[str]]:
     """
     adjusts options to make game completion possible
 
diff --git a/worlds/zillion/patch.py b/worlds/zillion/patch.py
index 6bc6d04dd663..0eee3315f4a1 100644
--- a/worlds/zillion/patch.py
+++ b/worlds/zillion/patch.py
@@ -1,5 +1,5 @@
 import os
-from typing import Any, BinaryIO, Optional, cast
+from typing import BinaryIO
 import zipfile
 
 from typing_extensions import override
@@ -11,11 +11,11 @@
 
 from .gen_data import GenData
 
-USHASH = 'd4bf9e7bcf9a48da53785d2ae7bc4270'
+US_HASH = "d4bf9e7bcf9a48da53785d2ae7bc4270"
 
 
 class ZillionPatch(APAutoPatchInterface):
-    hash = USHASH
+    hash = US_HASH
     game = "Zillion"
     patch_file_ending = ".apzl"
     result_file_ending = ".sms"
@@ -23,8 +23,14 @@ class ZillionPatch(APAutoPatchInterface):
     gen_data_str: str
     """ JSON encoded """
 
-    def __init__(self, *args: Any, gen_data_str: str = "", **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
+    def __init__(self,
+                 path: str | None = None,
+                 player: int | None = None,
+                 player_name: str = "",
+                 server: str = "",
+                 *,
+                 gen_data_str: str = "") -> None:
+        super().__init__(path=path, player=player, player_name=player_name, server=server)
         self.gen_data_str = gen_data_str
 
     @classmethod
@@ -44,15 +50,17 @@ def read_contents(self, opened_zipfile: zipfile.ZipFile) -> None:
         super().read_contents(opened_zipfile)
         self.gen_data_str = opened_zipfile.read("gen_data.json").decode()
 
+    @override
     def patch(self, target: str) -> None:
         self.read()
         write_rom_from_gen_data(self.gen_data_str, target)
 
 
-def get_base_rom_path(file_name: Optional[str] = None) -> str:
-    options = Utils.get_options()
+def get_base_rom_path(file_name: str | None = None) -> str:
+    from . import ZillionSettings, ZillionWorld
+    settings: ZillionSettings = ZillionWorld.settings
     if not file_name:
-        file_name = cast(str, options["zillion_options"]["rom_file"])
+        file_name = settings.rom_file
     if not os.path.exists(file_name):
         file_name = Utils.user_path(file_name)
     return file_name
diff --git a/worlds/zillion/region.py b/worlds/zillion/region.py
index cf5aa6588950..40565f008263 100644
--- a/worlds/zillion/region.py
+++ b/worlds/zillion/region.py
@@ -1,9 +1,11 @@
-from typing import Optional
-from BaseClasses import MultiWorld, Region, Location, Item, CollectionState
+from typing_extensions import override
+
 from zilliandomizer.logic_components.regions import Region as ZzRegion
 from zilliandomizer.logic_components.locations import Location as ZzLocation
 from zilliandomizer.logic_components.items import RESCUE
 
+from BaseClasses import MultiWorld, Region, Location, Item, CollectionState
+
 from .id_maps import loc_name_to_id
 from .item import ZillionItem
 
@@ -28,12 +30,12 @@ def __init__(self,
                  zz_loc: ZzLocation,
                  player: int,
                  name: str,
-                 parent: Optional[Region] = None) -> None:
+                 parent: Region | None = None) -> None:
         loc_id = loc_name_to_id[name]
         super().__init__(player, name, loc_id, parent)
         self.zz_loc = zz_loc
 
-    # override
+    @override
     def can_fill(self, state: CollectionState, item: Item, check_access: bool = True) -> bool:
         saved_gun_req = -1
         if isinstance(item, ZillionItem) \
diff --git a/worlds/zillion/test/TestReproducibleRandom.py b/worlds/zillion/test/TestReproducibleRandom.py
index a92fae240709..352165449a8b 100644
--- a/worlds/zillion/test/TestReproducibleRandom.py
+++ b/worlds/zillion/test/TestReproducibleRandom.py
@@ -1,4 +1,3 @@
-from typing import cast
 from . import ZillionTestBase
 
 from .. import ZillionWorld
@@ -9,7 +8,8 @@ class SeedTest(ZillionTestBase):
 
     def test_reproduce_seed(self) -> None:
         self.world_setup(42)
-        z_world = cast(ZillionWorld, self.multiworld.worlds[1])
+        z_world = self.multiworld.worlds[1]
+        assert isinstance(z_world, ZillionWorld)
         r = z_world.zz_system.randomizer
         assert r
         randomized_requirements_first = tuple(
@@ -18,7 +18,8 @@ def test_reproduce_seed(self) -> None:
         )
 
         self.world_setup(42)
-        z_world = cast(ZillionWorld, self.multiworld.worlds[1])
+        z_world = self.multiworld.worlds[1]
+        assert isinstance(z_world, ZillionWorld)
         r = z_world.zz_system.randomizer
         assert r
         randomized_requirements_second = tuple(
diff --git a/worlds/zillion/test/__init__.py b/worlds/zillion/test/__init__.py
index fe62bae34c9e..a669442364fe 100644
--- a/worlds/zillion/test/__init__.py
+++ b/worlds/zillion/test/__init__.py
@@ -1,4 +1,3 @@
-from typing import cast
 from test.bases import WorldTestBase
 from .. import ZillionWorld
 
@@ -13,8 +12,9 @@ def ensure_gun_3_requirement(self) -> None:
         This makes sure that gun 3 is required by making all the canisters
         in O-7 (including key word canisters) require gun 3.
         """
-        zz_world = cast(ZillionWorld, self.multiworld.worlds[1])
-        assert zz_world.zz_system.randomizer
-        for zz_loc_name, zz_loc in zz_world.zz_system.randomizer.locations.items():
+        z_world = self.multiworld.worlds[1]
+        assert isinstance(z_world, ZillionWorld)
+        assert z_world.zz_system.randomizer
+        for zz_loc_name, zz_loc in z_world.zz_system.randomizer.locations.items():
             if zz_loc_name.startswith("r15c6"):
                 zz_loc.req.gun = 3

From 8444ffa0c7cf8dbc404d7197204f4810d0a54214 Mon Sep 17 00:00:00 2001
From: Exempt-Medic <60412657+Exempt-Medic@users.noreply.github.com>
Date: Fri, 29 Nov 2024 15:34:14 -0500
Subject: [PATCH 11/20] id Tech: Standardizing and fixing display names (#4240)

---
 worlds/doom_1993/Options.py | 2 +-
 worlds/doom_ii/Options.py   | 2 +-
 worlds/heretic/Options.py   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/worlds/doom_1993/Options.py b/worlds/doom_1993/Options.py
index f65952d3eb49..b4fc50aac674 100644
--- a/worlds/doom_1993/Options.py
+++ b/worlds/doom_1993/Options.py
@@ -112,7 +112,7 @@ class StartWithComputerAreaMaps(Toggle):
 class ResetLevelOnDeath(DefaultOnToggle):
     """When dying, levels are reset and monsters respawned. But inventory and checks are kept.
     Turning this setting off is considered easy mode. Good for new players that don't know the levels well."""
-    display_name="Reset Level on Death"
+    display_name = "Reset Level on Death"
 
 
 class Episode1(DefaultOnToggle):
diff --git a/worlds/doom_ii/Options.py b/worlds/doom_ii/Options.py
index cc39512a176e..6ecfb1aecd6c 100644
--- a/worlds/doom_ii/Options.py
+++ b/worlds/doom_ii/Options.py
@@ -102,7 +102,7 @@ class StartWithComputerAreaMaps(Toggle):
 class ResetLevelOnDeath(DefaultOnToggle):
     """When dying, levels are reset and monsters respawned. But inventory and checks are kept.
     Turning this setting off is considered easy mode. Good for new players that don't know the levels well."""
-    display_message="Reset level on death"
+    display_name = "Reset Level on Death"
 
 
 class Episode1(DefaultOnToggle):
diff --git a/worlds/heretic/Options.py b/worlds/heretic/Options.py
index 75e2257a7336..14f4198a55f0 100644
--- a/worlds/heretic/Options.py
+++ b/worlds/heretic/Options.py
@@ -104,7 +104,7 @@ class StartWithMapScrolls(Toggle):
 class ResetLevelOnDeath(DefaultOnToggle):
     """When dying, levels are reset and monsters respawned. But inventory and checks are kept.
     Turning this setting off is considered easy mode. Good for new players that don't know the levels well."""
-    display_message="Reset level on death"
+    display_name = "Reset Level on Death"
 
     
 class CheckSanity(Toggle):

From c97e4866ddfd8eb31bdd3f22b1b63d1b91c62e03 Mon Sep 17 00:00:00 2001
From: NewSoupVi <57900059+NewSoupVi@users.noreply.github.com>
Date: Fri, 29 Nov 2024 22:43:01 +0100
Subject: [PATCH 12/20] Core: Rewrite start inventory from pool code (#3778)

* Rewrite start inventory from pool code

* I think this is nicer?

* lol

* I just made it even shorter and nicer

* comments :D

* I think this makes more logical sense

* final change I promise

* HOLD UP THIS IS SO SHORT NOW

* ???????? Vi pls

* ???????? Vi pls????????????????

* this was probably important idk

* Lmao this just did not work correctly at all
---
 Main.py | 65 +++++++++++++++++++++++++--------------------------------
 1 file changed, 29 insertions(+), 36 deletions(-)

diff --git a/Main.py b/Main.py
index 6b94b84c278b..606514630f0d 100644
--- a/Main.py
+++ b/Main.py
@@ -153,45 +153,38 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
 
     # remove starting inventory from pool items.
     # Because some worlds don't actually create items during create_items this has to be as late as possible.
-    if any(getattr(multiworld.worlds[player].options, "start_inventory_from_pool", None) for player in multiworld.player_ids):
-        new_items: List[Item] = []
-        old_items: List[Item] = []
-        depletion_pool: Dict[int, Dict[str, int]] = {
-            player: getattr(multiworld.worlds[player].options,
-                            "start_inventory_from_pool",
-                            StartInventoryPool({})).value.copy()
-            for player in multiworld.player_ids
-        }
-        for player, items in depletion_pool.items():
-            player_world: AutoWorld.World = multiworld.worlds[player]
-            for count in items.values():
-                for _ in range(count):
-                    new_items.append(player_world.create_filler())
-        target: int = sum(sum(items.values()) for items in depletion_pool.values())
-        for i, item in enumerate(multiworld.itempool):
+    fallback_inventory = StartInventoryPool({})
+    depletion_pool: Dict[int, Dict[str, int]] = {
+        player: getattr(multiworld.worlds[player].options, "start_inventory_from_pool", fallback_inventory).value.copy()
+        for player in multiworld.player_ids
+    }
+    target_per_player = {
+        player: sum(target_items.values()) for player, target_items in depletion_pool.items() if target_items
+    }
+
+    if target_per_player:
+        new_itempool: List[Item] = []
+
+        # Make new itempool with start_inventory_from_pool items removed
+        for item in multiworld.itempool:
             if depletion_pool[item.player].get(item.name, 0):
-                target -= 1
                 depletion_pool[item.player][item.name] -= 1
-                # quick abort if we have found all items
-                if not target:
-                    old_items.extend(multiworld.itempool[i+1:])
-                    break
             else:
-                old_items.append(item)
-
-        # leftovers?
-        if target:
-            for player, remaining_items in depletion_pool.items():
-                remaining_items = {name: count for name, count in remaining_items.items() if count}
-                if remaining_items:
-                    logger.warning(f"{multiworld.get_player_name(player)}"
-                                    f" is trying to remove items from their pool that don't exist: {remaining_items}")
-                    # find all filler we generated for the current player and remove until it matches 
-                    removables = [item for item in new_items if item.player == player]
-                    for _ in range(sum(remaining_items.values())):
-                        new_items.remove(removables.pop())
-        assert len(multiworld.itempool) == len(new_items + old_items), "Item Pool amounts should not change."
-        multiworld.itempool[:] = new_items + old_items
+                new_itempool.append(item)
+
+        # Create filler in place of the removed items, warn if any items couldn't be found in the multiworld itempool
+        for player, target in target_per_player.items():
+            unfound_items = {item: count for item, count in depletion_pool[player].items() if count}
+
+            if unfound_items:
+                player_name = multiworld.get_player_name(player)
+                logger.warning(f"{player_name} tried to remove items from their pool that don't exist: {unfound_items}")
+
+            needed_items = target_per_player[player] - sum(unfound_items.values())
+            new_itempool += [multiworld.worlds[player].create_filler() for _ in range(needed_items)]
+
+        assert len(multiworld.itempool) == len(new_itempool), "Item Pool amounts should not change."
+        multiworld.itempool[:] = new_itempool
 
     multiworld.link_items()
 

From 6e5adc7abdecf4baf6a29d89934cfe6cea0cba82 Mon Sep 17 00:00:00 2001
From: David St-Louis <daivuk@gmail.com>
Date: Fri, 29 Nov 2024 16:45:36 -0500
Subject: [PATCH 13/20] New Game: Faxanadu (#3059)

---
 README.md                           |   1 +
 docs/CODEOWNERS                     |   3 +
 worlds/faxanadu/Items.py            |  58 ++++++++
 worlds/faxanadu/Locations.py        | 199 ++++++++++++++++++++++++++++
 worlds/faxanadu/Options.py          | 107 +++++++++++++++
 worlds/faxanadu/Regions.py          |  66 +++++++++
 worlds/faxanadu/Rules.py            |  79 +++++++++++
 worlds/faxanadu/__init__.py         | 190 ++++++++++++++++++++++++++
 worlds/faxanadu/docs/en_Faxanadu.md |  27 ++++
 worlds/faxanadu/docs/setup_en.md    |  32 +++++
 10 files changed, 762 insertions(+)
 create mode 100644 worlds/faxanadu/Items.py
 create mode 100644 worlds/faxanadu/Locations.py
 create mode 100644 worlds/faxanadu/Options.py
 create mode 100644 worlds/faxanadu/Regions.py
 create mode 100644 worlds/faxanadu/Rules.py
 create mode 100644 worlds/faxanadu/__init__.py
 create mode 100644 worlds/faxanadu/docs/en_Faxanadu.md
 create mode 100644 worlds/faxanadu/docs/setup_en.md

diff --git a/README.md b/README.md
index 0e57bce53b51..2cc3c18aa09d 100644
--- a/README.md
+++ b/README.md
@@ -76,6 +76,7 @@ Currently, the following games are supported:
 * Kingdom Hearts 1
 * Mega Man 2
 * Yacht Dice
+* Faxanadu
 
 For setup and instructions check out our [tutorials page](https://archipelago.gg/tutorial/).
 Downloads can be found at [Releases](https://github.com/ArchipelagoMW/Archipelago/releases), including compiled
diff --git a/docs/CODEOWNERS b/docs/CODEOWNERS
index a51cac37026b..4b7496c686c8 100644
--- a/docs/CODEOWNERS
+++ b/docs/CODEOWNERS
@@ -63,6 +63,9 @@
 # Factorio
 /worlds/factorio/ @Berserker66
 
+# Faxanadu
+/worlds/faxanadu/ @Daivuk
+
 # Final Fantasy Mystic Quest
 /worlds/ffmq/ @Alchav @wildham0
 
diff --git a/worlds/faxanadu/Items.py b/worlds/faxanadu/Items.py
new file mode 100644
index 000000000000..4815fde9de66
--- /dev/null
+++ b/worlds/faxanadu/Items.py
@@ -0,0 +1,58 @@
+from BaseClasses import ItemClassification
+from typing import List, Optional
+
+
+class ItemDef:
+    def __init__(self,
+                 id: Optional[int],
+                 name: str,
+                 classification: ItemClassification,
+                 count: int,
+                 progression_count: int,
+                 prefill_location: Optional[str]):
+        self.id = id
+        self.name = name
+        self.classification = classification
+        self.count = count
+        self.progression_count = progression_count
+        self.prefill_location = prefill_location
+
+
+items: List[ItemDef] = [
+    ItemDef(400000, 'Progressive Sword', ItemClassification.progression, 4, 0, None),
+    ItemDef(400001, 'Progressive Armor', ItemClassification.progression, 3, 0, None),
+    ItemDef(400002, 'Progressive Shield', ItemClassification.useful, 4, 0, None),
+    ItemDef(400003, 'Spring Elixir', ItemClassification.progression, 1, 0, None),
+    ItemDef(400004, 'Mattock', ItemClassification.progression, 1, 0, None),
+    ItemDef(400005, 'Unlock Wingboots', ItemClassification.progression, 1, 0, None),
+    ItemDef(400006, 'Key Jack', ItemClassification.progression, 1, 0, None),
+    ItemDef(400007, 'Key Queen', ItemClassification.progression, 1, 0, None),
+    ItemDef(400008, 'Key King', ItemClassification.progression, 1, 0, None),
+    ItemDef(400009, 'Key Joker', ItemClassification.progression, 1, 0, None),
+    ItemDef(400010, 'Key Ace', ItemClassification.progression, 1, 0, None),
+    ItemDef(400011, 'Ring of Ruby', ItemClassification.progression, 1, 0, None),
+    ItemDef(400012, 'Ring of Dworf', ItemClassification.progression, 1, 0, None),
+    ItemDef(400013, 'Demons Ring', ItemClassification.progression, 1, 0, None),
+    ItemDef(400014, 'Black Onyx', ItemClassification.progression, 1, 0, None),
+    ItemDef(None, 'Sky Spring Flow', ItemClassification.progression, 1, 0, 'Sky Spring'),
+    ItemDef(None, 'Tower of Fortress Spring Flow', ItemClassification.progression, 1, 0, 'Tower of Fortress Spring'),
+    ItemDef(None, 'Joker Spring Flow', ItemClassification.progression, 1, 0, 'Joker Spring'),
+    ItemDef(400015, 'Deluge', ItemClassification.progression, 1, 0, None),
+    ItemDef(400016, 'Thunder', ItemClassification.useful, 1, 0, None),
+    ItemDef(400017, 'Fire', ItemClassification.useful, 1, 0, None),
+    ItemDef(400018, 'Death', ItemClassification.useful, 1, 0, None),
+    ItemDef(400019, 'Tilte', ItemClassification.useful, 1, 0, None),
+    ItemDef(400020, 'Ring of Elf', ItemClassification.useful, 1, 0, None),
+    ItemDef(400021, 'Magical Rod', ItemClassification.useful, 1, 0, None),
+    ItemDef(400022, 'Pendant', ItemClassification.useful, 1, 0, None),
+    ItemDef(400023, 'Hourglass', ItemClassification.filler, 6, 0, None),
+    # We need at least 4 red potions for the Tower of Red Potion. Up to the player to save them up!
+    ItemDef(400024, 'Red Potion', ItemClassification.filler, 15, 4, None),
+    ItemDef(400025, 'Elixir', ItemClassification.filler, 4, 0, None),
+    ItemDef(400026, 'Glove', ItemClassification.filler, 5, 0, None),
+    ItemDef(400027, 'Ointment', ItemClassification.filler, 8, 0, None),
+    ItemDef(400028, 'Poison', ItemClassification.trap, 13, 0, None),
+    ItemDef(None, 'Killed Evil One', ItemClassification.progression, 1, 0, 'Evil One'),
+    # Placeholder item so the game knows which shop slot to prefill wingboots
+    ItemDef(400029, 'Wingboots', ItemClassification.useful, 0, 0, None),
+]
diff --git a/worlds/faxanadu/Locations.py b/worlds/faxanadu/Locations.py
new file mode 100644
index 000000000000..ebb785f9391a
--- /dev/null
+++ b/worlds/faxanadu/Locations.py
@@ -0,0 +1,199 @@
+from typing import List, Optional
+
+
+class LocationType():
+    world = 1  # Just standing there in the world
+    hidden = 2  # Kill all monsters in the room to reveal, each "item room" counter tick.
+    boss_reward = 3  # Kill a boss to reveal the item
+    shop = 4  # Buy at a shop
+    give = 5  # Given by an NPC
+    spring = 6  # Activatable spring
+    boss = 7  # Entity to kill to trigger the check
+
+
+class ItemType():
+    unknown = 0  # Or don't care
+    red_potion = 1
+
+
+class LocationDef:
+    def __init__(self, id: Optional[int], name: str, region: str, type: int, original_item: int):
+        self.id = id
+        self.name = name
+        self.region = region
+        self.type = type
+        self.original_item = original_item
+
+
+locations: List[LocationDef] = [
+    # Eolis
+    LocationDef(400100, 'Eolis Guru', 'Eolis', LocationType.give, ItemType.unknown),
+    LocationDef(400101, 'Eolis Key Jack', 'Eolis', LocationType.shop, ItemType.unknown),
+    LocationDef(400102, 'Eolis Hand Dagger', 'Eolis', LocationType.shop, ItemType.unknown),
+    LocationDef(400103, 'Eolis Red Potion', 'Eolis', LocationType.shop, ItemType.red_potion),
+    LocationDef(400104, 'Eolis Elixir', 'Eolis', LocationType.shop, ItemType.unknown),
+    LocationDef(400105, 'Eolis Deluge', 'Eolis', LocationType.shop, ItemType.unknown),
+
+    # Path to Apolune
+    LocationDef(400106, 'Path to Apolune Magic Shield', 'Path to Apolune', LocationType.shop, ItemType.unknown),
+    LocationDef(400107, 'Path to Apolune Death', 'Path to Apolune', LocationType.shop, ItemType.unknown),
+
+    # Apolune
+    LocationDef(400108, 'Apolune Small Shield', 'Apolune', LocationType.shop, ItemType.unknown),
+    LocationDef(400109, 'Apolune Hand Dagger', 'Apolune', LocationType.shop, ItemType.unknown),
+    LocationDef(400110, 'Apolune Deluge', 'Apolune', LocationType.shop, ItemType.unknown),
+    LocationDef(400111, 'Apolune Red Potion', 'Apolune', LocationType.shop, ItemType.red_potion),
+    LocationDef(400112, 'Apolune Key Jack', 'Apolune', LocationType.shop, ItemType.unknown),
+
+    # Tower of Trunk
+    LocationDef(400113, 'Tower of Trunk Hidden Mattock', 'Tower of Trunk', LocationType.hidden, ItemType.unknown),
+    LocationDef(400114, 'Tower of Trunk Hidden Hourglass', 'Tower of Trunk', LocationType.hidden, ItemType.unknown),
+    LocationDef(400115, 'Tower of Trunk Boss Mattock', 'Tower of Trunk', LocationType.boss_reward, ItemType.unknown),
+
+    # Path to Forepaw
+    LocationDef(400116, 'Path to Forepaw Hidden Red Potion', 'Path to Forepaw', LocationType.hidden, ItemType.red_potion),
+    LocationDef(400117, 'Path to Forepaw Glove', 'Path to Forepaw', LocationType.world, ItemType.unknown),
+
+    # Forepaw
+    LocationDef(400118, 'Forepaw Long Sword', 'Forepaw', LocationType.shop, ItemType.unknown),
+    LocationDef(400119, 'Forepaw Studded Mail', 'Forepaw', LocationType.shop, ItemType.unknown),
+    LocationDef(400120, 'Forepaw Small Shield', 'Forepaw', LocationType.shop, ItemType.unknown),
+    LocationDef(400121, 'Forepaw Red Potion', 'Forepaw', LocationType.shop, ItemType.red_potion),
+    LocationDef(400122, 'Forepaw Wingboots', 'Forepaw', LocationType.shop, ItemType.unknown),
+    LocationDef(400123, 'Forepaw Key Jack', 'Forepaw', LocationType.shop, ItemType.unknown),
+    LocationDef(400124, 'Forepaw Key Queen', 'Forepaw', LocationType.shop, ItemType.unknown),
+
+    # Trunk
+    LocationDef(400125, 'Trunk Hidden Ointment', 'Trunk', LocationType.hidden, ItemType.unknown),
+    LocationDef(400126, 'Trunk Hidden Red Potion', 'Trunk', LocationType.hidden, ItemType.red_potion),
+    LocationDef(400127, 'Trunk Red Potion', 'Trunk', LocationType.world, ItemType.red_potion),
+    LocationDef(None, 'Sky Spring', 'Trunk', LocationType.spring, ItemType.unknown),
+
+    # Joker Spring
+    LocationDef(400128, 'Joker Spring Ruby Ring', 'Joker Spring', LocationType.give, ItemType.unknown),
+    LocationDef(None, 'Joker Spring', 'Joker Spring', LocationType.spring, ItemType.unknown),
+
+    # Tower of Fortress
+    LocationDef(400129, 'Tower of Fortress Poison 1', 'Tower of Fortress', LocationType.world, ItemType.unknown),
+    LocationDef(400130, 'Tower of Fortress Poison 2', 'Tower of Fortress', LocationType.world, ItemType.unknown),
+    LocationDef(400131, 'Tower of Fortress Hidden Wingboots', 'Tower of Fortress', LocationType.world, ItemType.unknown),
+    LocationDef(400132, 'Tower of Fortress Ointment', 'Tower of Fortress', LocationType.world, ItemType.unknown),
+    LocationDef(400133, 'Tower of Fortress Boss Wingboots', 'Tower of Fortress', LocationType.boss_reward, ItemType.unknown),
+    LocationDef(400134, 'Tower of Fortress Elixir', 'Tower of Fortress', LocationType.world, ItemType.unknown),
+    LocationDef(400135, 'Tower of Fortress Guru', 'Tower of Fortress', LocationType.give, ItemType.unknown),
+    LocationDef(None, 'Tower of Fortress Spring', 'Tower of Fortress', LocationType.spring, ItemType.unknown),
+
+    # Path to Mascon
+    LocationDef(400136, 'Path to Mascon Hidden Wingboots', 'Path to Mascon', LocationType.hidden, ItemType.unknown),
+
+    # Tower of Red Potion
+    LocationDef(400137, 'Tower of Red Potion', 'Tower of Red Potion', LocationType.world, ItemType.red_potion),
+
+    # Mascon
+    LocationDef(400138, 'Mascon Large Shield', 'Mascon', LocationType.shop, ItemType.unknown),
+    LocationDef(400139, 'Mascon Thunder', 'Mascon', LocationType.shop, ItemType.unknown),
+    LocationDef(400140, 'Mascon Mattock', 'Mascon', LocationType.shop, ItemType.unknown),
+    LocationDef(400141, 'Mascon Red Potion', 'Mascon', LocationType.shop, ItemType.red_potion),
+    LocationDef(400142, 'Mascon Key Jack', 'Mascon', LocationType.shop, ItemType.unknown),
+    LocationDef(400143, 'Mascon Key Queen', 'Mascon', LocationType.shop, ItemType.unknown),
+
+    # Path to Victim
+    LocationDef(400144, 'Misty Shop Death', 'Path to Victim', LocationType.shop, ItemType.unknown),
+    LocationDef(400145, 'Misty Shop Hourglass', 'Path to Victim', LocationType.shop, ItemType.unknown),
+    LocationDef(400146, 'Misty Shop Elixir', 'Path to Victim', LocationType.shop, ItemType.unknown),
+    LocationDef(400147, 'Misty Shop Red Potion', 'Path to Victim', LocationType.shop, ItemType.red_potion),
+    LocationDef(400148, 'Misty Doctor Office', 'Path to Victim', LocationType.hidden, ItemType.unknown),
+
+    # Tower of Suffer
+    LocationDef(400149, 'Tower of Suffer Hidden Wingboots', 'Tower of Suffer', LocationType.hidden, ItemType.unknown),
+    LocationDef(400150, 'Tower of Suffer Hidden Hourglass', 'Tower of Suffer', LocationType.hidden, ItemType.unknown),
+    LocationDef(400151, 'Tower of Suffer Pendant', 'Tower of Suffer', LocationType.boss_reward, ItemType.unknown),
+
+    # Victim
+    LocationDef(400152, 'Victim Full Plate', 'Victim', LocationType.shop, ItemType.unknown),
+    LocationDef(400153, 'Victim Mattock', 'Victim', LocationType.shop, ItemType.unknown),
+    LocationDef(400154, 'Victim Red Potion', 'Victim', LocationType.shop, ItemType.red_potion),
+    LocationDef(400155, 'Victim Key King', 'Victim', LocationType.shop, ItemType.unknown),
+    LocationDef(400156, 'Victim Key Queen', 'Victim', LocationType.shop, ItemType.unknown),
+    LocationDef(400157, 'Victim Tavern', 'Mist', LocationType.give, ItemType.unknown),
+
+    # Mist
+    LocationDef(400158, 'Mist Hidden Poison 1', 'Mist', LocationType.hidden, ItemType.unknown),
+    LocationDef(400159, 'Mist Hidden Poison 2', 'Mist', LocationType.hidden, ItemType.unknown),
+    LocationDef(400160, 'Mist Hidden Wingboots', 'Mist', LocationType.hidden, ItemType.unknown),
+    LocationDef(400161, 'Misty Magic Hall', 'Mist', LocationType.give, ItemType.unknown),
+    LocationDef(400162, 'Misty House', 'Mist', LocationType.give, ItemType.unknown),
+
+    # Useless Tower
+    LocationDef(400163, 'Useless Tower', 'Useless Tower', LocationType.hidden, ItemType.unknown),
+
+    # Tower of Mist
+    LocationDef(400164, 'Tower of Mist Hidden Ointment', 'Tower of Mist', LocationType.hidden, ItemType.unknown),
+    LocationDef(400165, 'Tower of Mist Elixir', 'Tower of Mist', LocationType.world, ItemType.unknown),
+    LocationDef(400166, 'Tower of Mist Black Onyx', 'Tower of Mist', LocationType.boss_reward, ItemType.unknown),
+
+    # Path to Conflate
+    LocationDef(400167, 'Path to Conflate Hidden Ointment', 'Path to Conflate', LocationType.hidden, ItemType.unknown),
+    LocationDef(400168, 'Path to Conflate Poison', 'Path to Conflate', LocationType.hidden, ItemType.unknown),
+
+    # Helm Branch
+    LocationDef(400169, 'Helm Branch Hidden Glove', 'Helm Branch', LocationType.hidden, ItemType.unknown),
+    LocationDef(400170, 'Helm Branch Battle Helmet', 'Helm Branch', LocationType.boss_reward, ItemType.unknown),
+
+    # Conflate
+    LocationDef(400171, 'Conflate Giant Blade', 'Conflate', LocationType.shop, ItemType.unknown),
+    LocationDef(400172, 'Conflate Magic Shield', 'Conflate', LocationType.shop, ItemType.unknown),
+    LocationDef(400173, 'Conflate Wingboots', 'Conflate', LocationType.shop, ItemType.unknown),
+    LocationDef(400174, 'Conflate Red Potion', 'Conflate', LocationType.shop, ItemType.red_potion),
+    LocationDef(400175, 'Conflate Guru', 'Conflate', LocationType.give, ItemType.unknown),
+
+    # Branches
+    LocationDef(400176, 'Branches Hidden Ointment', 'Branches', LocationType.hidden, ItemType.unknown),
+    LocationDef(400177, 'Branches Poison', 'Branches', LocationType.world, ItemType.unknown),
+    LocationDef(400178, 'Branches Hidden Mattock', 'Branches', LocationType.hidden, ItemType.unknown),
+    LocationDef(400179, 'Branches Hidden Hourglass', 'Branches', LocationType.hidden, ItemType.unknown),
+
+    # Path to Daybreak
+    LocationDef(400180, 'Path to Daybreak Hidden Wingboots 1', 'Path to Daybreak', LocationType.hidden, ItemType.unknown),
+    LocationDef(400181, 'Path to Daybreak Magical Rod', 'Path to Daybreak', LocationType.world, ItemType.unknown),
+    LocationDef(400182, 'Path to Daybreak Hidden Wingboots 2', 'Path to Daybreak', LocationType.hidden, ItemType.unknown),
+    LocationDef(400183, 'Path to Daybreak Poison', 'Path to Daybreak', LocationType.world, ItemType.unknown),
+    LocationDef(400184, 'Path to Daybreak Glove', 'Path to Daybreak', LocationType.world, ItemType.unknown),
+    LocationDef(400185, 'Path to Daybreak Battle Suit', 'Path to Daybreak', LocationType.boss_reward, ItemType.unknown),
+
+    # Daybreak
+    LocationDef(400186, 'Daybreak Tilte', 'Daybreak', LocationType.shop, ItemType.unknown),
+    LocationDef(400187, 'Daybreak Giant Blade', 'Daybreak', LocationType.shop, ItemType.unknown),
+    LocationDef(400188, 'Daybreak Red Potion', 'Daybreak', LocationType.shop, ItemType.red_potion),
+    LocationDef(400189, 'Daybreak Key King', 'Daybreak', LocationType.shop, ItemType.unknown),
+    LocationDef(400190, 'Daybreak Key Queen', 'Daybreak', LocationType.shop, ItemType.unknown),
+
+    # Dartmoor Castle
+    LocationDef(400191, 'Dartmoor Castle Hidden Hourglass', 'Dartmoor Castle', LocationType.hidden, ItemType.unknown),
+    LocationDef(400192, 'Dartmoor Castle Hidden Red Potion', 'Dartmoor Castle', LocationType.hidden, ItemType.red_potion),
+
+    # Dartmoor
+    LocationDef(400193, 'Dartmoor Giant Blade', 'Dartmoor', LocationType.shop, ItemType.unknown),
+    LocationDef(400194, 'Dartmoor Red Potion', 'Dartmoor', LocationType.shop, ItemType.red_potion),
+    LocationDef(400195, 'Dartmoor Key King', 'Dartmoor', LocationType.shop, ItemType.unknown),
+
+    # Fraternal Castle
+    LocationDef(400196, 'Fraternal Castle Hidden Ointment', 'Fraternal Castle', LocationType.hidden, ItemType.unknown),
+    LocationDef(400197, 'Fraternal Castle Shop Hidden Ointment', 'Fraternal Castle', LocationType.hidden, ItemType.unknown),
+    LocationDef(400198, 'Fraternal Castle Poison 1', 'Fraternal Castle', LocationType.world, ItemType.unknown),
+    LocationDef(400199, 'Fraternal Castle Poison 2', 'Fraternal Castle', LocationType.world, ItemType.unknown),
+    LocationDef(400200, 'Fraternal Castle Poison 3', 'Fraternal Castle', LocationType.world, ItemType.unknown),
+    # LocationDef(400201, 'Fraternal Castle Red Potion', 'Fraternal Castle', LocationType.world, ItemType.red_potion),  # This location is inaccessible. Keeping commented for context.
+    LocationDef(400202, 'Fraternal Castle Hidden Hourglass', 'Fraternal Castle', LocationType.hidden, ItemType.unknown),
+    LocationDef(400203, 'Fraternal Castle Dragon Slayer', 'Fraternal Castle', LocationType.boss_reward, ItemType.unknown),
+    LocationDef(400204, 'Fraternal Castle Guru', 'Fraternal Castle', LocationType.give, ItemType.unknown),
+
+    # Evil Fortress
+    LocationDef(400205, 'Evil Fortress Ointment', 'Evil Fortress', LocationType.world, ItemType.unknown),
+    LocationDef(400206, 'Evil Fortress Poison 1', 'Evil Fortress', LocationType.world, ItemType.unknown),
+    LocationDef(400207, 'Evil Fortress Glove', 'Evil Fortress', LocationType.world, ItemType.unknown),
+    LocationDef(400208, 'Evil Fortress Poison 2', 'Evil Fortress', LocationType.world, ItemType.unknown),
+    LocationDef(400209, 'Evil Fortress Poison 3', 'Evil Fortress', LocationType.world, ItemType.unknown),
+    LocationDef(400210, 'Evil Fortress Hidden Glove', 'Evil Fortress', LocationType.hidden, ItemType.unknown),
+    LocationDef(None, 'Evil One', 'Evil Fortress', LocationType.boss, ItemType.unknown),
+]
diff --git a/worlds/faxanadu/Options.py b/worlds/faxanadu/Options.py
new file mode 100644
index 000000000000..dbcb5789944f
--- /dev/null
+++ b/worlds/faxanadu/Options.py
@@ -0,0 +1,107 @@
+from Options import PerGameCommonOptions, Toggle, DefaultOnToggle, StartInventoryPool, Choice
+from dataclasses import dataclass
+
+
+class KeepShopRedPotions(Toggle):
+    """
+    Prevents the Shop's Red Potions from being shuffled. Those locations
+    will have purchasable Red Potion as usual for their usual price.
+    """
+    display_name = "Keep Shop Red Potions"
+
+
+class IncludePendant(Toggle):
+    """
+    Pendant is an item that boosts your attack power permanently when picked up.
+    However, due to a programming error in the original game, it has the reverse
+    effect. You start with the Pendant power, and lose it when picking
+    it up. So this item is essentially a trap.
+    There is a setting in the client to reverse the effect back to its original intend.
+    This could be used in conjunction with this option to increase or lower difficulty.
+    """
+    display_name = "Include Pendant"
+
+
+class IncludePoisons(DefaultOnToggle):
+    """
+    Whether or not to include Poison Potions in the pool of items. Including them
+    effectively turn them into traps in multiplayer.
+    """
+    display_name = "Include Poisons"
+
+
+class RequireDragonSlayer(Toggle):
+    """
+    Requires the Dragon Slayer to be available before fighting the final boss is required.
+    Turning this on will turn Progressive Shields into progression items.
+
+    This setting does not force you to use Dragon Slayer to kill the final boss.
+    Instead, it ensures that you will have the Dragon Slayer and be able to equip
+    it before you are expected to beat the final boss.
+    """
+    display_name = "Require Dragon Slayer"
+
+
+class RandomMusic(Toggle):
+    """
+    All levels' music is shuffled. Except the title screen because it's finite.
+    This is an aesthetic option and doesn't affect gameplay.
+    """
+    display_name = "Random Musics"
+
+
+class RandomSound(Toggle):
+    """
+    All sounds are shuffled.
+    This is an aesthetic option and doesn't affect gameplay.
+    """
+    display_name = "Random Sounds"
+
+
+class RandomNPC(Toggle):
+    """
+    NPCs and their portraits are shuffled.
+    This is an aesthetic option and doesn't affect gameplay.
+    """
+    display_name = "Random NPCs"
+
+
+class RandomMonsters(Choice):
+    """
+    Choose how monsters are randomized.
+    "Vanilla": No randomization
+    "Level Shuffle": Monsters are shuffled within a level
+    "Level Random": Monsters are picked randomly, balanced based on the ratio of the current level
+    "World Shuffle": Monsters are shuffled across the entire world
+    "World Random": Monsters are picked randomly, balanced based on the ratio of the entire world
+    "Chaotic": Completely random, except big vs small ratio is kept. Big are mini-bosses.
+    """
+    display_name = "Random Monsters"
+    option_vanilla = 0
+    option_level_shuffle = 1
+    option_level_random = 2
+    option_world_shuffle = 3
+    option_world_random = 4
+    option_chaotic = 5
+    default = 0
+
+
+class RandomRewards(Toggle):
+    """
+    Monsters drops are shuffled.
+    """
+    display_name = "Random Rewards"
+
+
+@dataclass
+class FaxanaduOptions(PerGameCommonOptions):
+    start_inventory_from_pool: StartInventoryPool
+    keep_shop_red_potions: KeepShopRedPotions
+    include_pendant: IncludePendant
+    include_poisons: IncludePoisons
+    require_dragon_slayer: RequireDragonSlayer
+    random_musics: RandomMusic
+    random_sounds: RandomSound
+    random_npcs: RandomNPC
+    random_monsters: RandomMonsters
+    random_rewards: RandomRewards
diff --git a/worlds/faxanadu/Regions.py b/worlds/faxanadu/Regions.py
new file mode 100644
index 000000000000..9db11d8ef114
--- /dev/null
+++ b/worlds/faxanadu/Regions.py
@@ -0,0 +1,66 @@
+from BaseClasses import Region
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from . import FaxanaduWorld
+
+
+def create_region(name, player, multiworld):
+    region = Region(name, player, multiworld)
+    multiworld.regions.append(region)
+    return region
+
+
+def create_regions(faxanadu_world: "FaxanaduWorld"):
+    player = faxanadu_world.player
+    multiworld = faxanadu_world.multiworld
+
+    # Create regions
+    menu = create_region("Menu", player, multiworld)
+    eolis = create_region("Eolis", player, multiworld)
+    path_to_apolune = create_region("Path to Apolune", player, multiworld)
+    apolune = create_region("Apolune", player, multiworld)
+    create_region("Tower of Trunk", player, multiworld)
+    path_to_forepaw = create_region("Path to Forepaw", player, multiworld)
+    forepaw = create_region("Forepaw", player, multiworld)
+    trunk = create_region("Trunk", player, multiworld)
+    create_region("Joker Spring", player, multiworld)
+    create_region("Tower of Fortress", player, multiworld)
+    path_to_mascon = create_region("Path to Mascon", player, multiworld)
+    create_region("Tower of Red Potion", player, multiworld)
+    mascon = create_region("Mascon", player, multiworld)
+    path_to_victim = create_region("Path to Victim", player, multiworld)
+    create_region("Tower of Suffer", player, multiworld)
+    victim = create_region("Victim", player, multiworld)
+    mist = create_region("Mist", player, multiworld)
+    create_region("Useless Tower", player, multiworld)
+    create_region("Tower of Mist", player, multiworld)
+    path_to_conflate = create_region("Path to Conflate", player, multiworld)
+    create_region("Helm Branch", player, multiworld)
+    create_region("Conflate", player, multiworld)
+    branches = create_region("Branches", player, multiworld)
+    path_to_daybreak = create_region("Path to Daybreak", player, multiworld)
+    daybreak = create_region("Daybreak", player, multiworld)
+    dartmoor_castle = create_region("Dartmoor Castle", player, multiworld)
+    create_region("Dartmoor", player, multiworld)
+    create_region("Fraternal Castle", player, multiworld)
+    create_region("Evil Fortress", player, multiworld)
+
+    # Create connections
+    menu.add_exits(["Eolis"])
+    eolis.add_exits(["Path to Apolune"])
+    path_to_apolune.add_exits(["Apolune"])
+    apolune.add_exits(["Tower of Trunk", "Path to Forepaw"])
+    path_to_forepaw.add_exits(["Forepaw"])
+    forepaw.add_exits(["Trunk"])
+    trunk.add_exits(["Joker Spring", "Tower of Fortress", "Path to Mascon"])
+    path_to_mascon.add_exits(["Tower of Red Potion", "Mascon"])
+    mascon.add_exits(["Path to Victim"])
+    path_to_victim.add_exits(["Tower of Suffer", "Victim"])
+    victim.add_exits(["Mist"])
+    mist.add_exits(["Useless Tower", "Tower of Mist", "Path to Conflate"])
+    path_to_conflate.add_exits(["Helm Branch", "Conflate", "Branches"])
+    branches.add_exits(["Path to Daybreak"])
+    path_to_daybreak.add_exits(["Daybreak"])
+    daybreak.add_exits(["Dartmoor Castle"])
+    dartmoor_castle.add_exits(["Dartmoor", "Fraternal Castle", "Evil Fortress"])
diff --git a/worlds/faxanadu/Rules.py b/worlds/faxanadu/Rules.py
new file mode 100644
index 000000000000..a48b442c107a
--- /dev/null
+++ b/worlds/faxanadu/Rules.py
@@ -0,0 +1,79 @@
+from typing import TYPE_CHECKING
+from worlds.generic.Rules import set_rule
+
+if TYPE_CHECKING:
+    from . import FaxanaduWorld
+
+
+def can_buy_in_eolis(state, player):
+    # Sword or Deluge so we can farm for gold.
+    # Ring of Elf so we can get 1500 from the King.
+    return state.has_any(["Progressive Sword", "Deluge", "Ring of Elf"], player)
+
+
+def has_any_magic(state, player):
+    return state.has_any(["Deluge", "Thunder", "Fire", "Death", "Tilte"], player)
+
+
+def set_rules(faxanadu_world: "FaxanaduWorld"):
+    player = faxanadu_world.player
+    multiworld = faxanadu_world.multiworld
+
+    # Region rules
+    set_rule(multiworld.get_entrance("Eolis -> Path to Apolune", player), lambda state:
+             state.has_all(["Key Jack", "Progressive Sword"], player))  # You can't go far with magic only
+    set_rule(multiworld.get_entrance("Apolune -> Tower of Trunk", player), lambda state: state.has("Key Jack", player))
+    set_rule(multiworld.get_entrance("Apolune -> Path to Forepaw", player), lambda state: state.has("Mattock", player))
+    set_rule(multiworld.get_entrance("Trunk -> Joker Spring", player), lambda state: state.has("Key Joker", player))
+    set_rule(multiworld.get_entrance("Trunk -> Tower of Fortress", player), lambda state: state.has("Key Jack", player))
+    set_rule(multiworld.get_entrance("Trunk -> Path to Mascon", player), lambda state: 
+             state.has_all(["Key Queen", "Ring of Ruby", "Sky Spring Flow", "Tower of Fortress Spring Flow", "Joker Spring Flow"], player) and 
+             state.has("Progressive Sword", player, 2))
+    set_rule(multiworld.get_entrance("Path to Mascon -> Tower of Red Potion", player), lambda state:
+             state.has("Key Queen", player) and
+             state.has("Red Potion", player, 4))  # It's impossible to go through the tower of Red Potion without at least 1-2 potions. Give them 4 for good measure.
+    set_rule(multiworld.get_entrance("Path to Victim -> Tower of Suffer", player), lambda state: state.has("Key Queen", player))
+    set_rule(multiworld.get_entrance("Path to Victim -> Victim", player), lambda state: state.has("Unlock Wingboots", player))
+    set_rule(multiworld.get_entrance("Mist -> Useless Tower", player), lambda state:
+             state.has_all(["Key King", "Unlock Wingboots"], player))
+    set_rule(multiworld.get_entrance("Mist -> Tower of Mist", player), lambda state: state.has("Key King", player))
+    set_rule(multiworld.get_entrance("Mist -> Path to Conflate", player), lambda state: state.has("Key Ace", player))
+    set_rule(multiworld.get_entrance("Path to Conflate -> Helm Branch", player), lambda state: state.has("Key King", player))
+    set_rule(multiworld.get_entrance("Path to Conflate -> Branches", player), lambda state: state.has("Key King", player))
+    set_rule(multiworld.get_entrance("Daybreak -> Dartmoor Castle", player), lambda state: state.has("Ring of Dworf", player))
+    set_rule(multiworld.get_entrance("Dartmoor Castle -> Evil Fortress", player), lambda state: state.has("Demons Ring", player))
+
+    # Location rules
+    set_rule(multiworld.get_location("Eolis Key Jack", player), lambda state: can_buy_in_eolis(state, player))
+    set_rule(multiworld.get_location("Eolis Hand Dagger", player), lambda state: can_buy_in_eolis(state, player))
+    set_rule(multiworld.get_location("Eolis Elixir", player), lambda state: can_buy_in_eolis(state, player))
+    set_rule(multiworld.get_location("Eolis Deluge", player), lambda state: can_buy_in_eolis(state, player))
+    set_rule(multiworld.get_location("Eolis Red Potion", player), lambda state: can_buy_in_eolis(state, player))
+    set_rule(multiworld.get_location("Path to Apolune Magic Shield", player), lambda state: state.has("Key King", player))  # Mid-late cost, make sure we've progressed
+    set_rule(multiworld.get_location("Path to Apolune Death", player), lambda state: state.has("Key Ace", player))  # Mid-late cost, make sure we've progressed
+    set_rule(multiworld.get_location("Tower of Trunk Hidden Mattock", player), lambda state:
+             # This is actually possible if the monster drop into the stairs and kill it with dagger. But it's a "pro move"
+             state.has("Deluge", player, 1) or
+             state.has("Progressive Sword", player, 2))
+    set_rule(multiworld.get_location("Path to Forepaw Glove", player), lambda state:
+             state.has_all(["Deluge", "Unlock Wingboots"], player))
+    set_rule(multiworld.get_location("Trunk Red Potion", player), lambda state: state.has("Unlock Wingboots", player))
+    set_rule(multiworld.get_location("Sky Spring", player), lambda state: state.has("Unlock Wingboots", player))
+    set_rule(multiworld.get_location("Tower of Fortress Spring", player), lambda state: state.has("Spring Elixir", player))
+    set_rule(multiworld.get_location("Tower of Fortress Guru", player), lambda state: state.has("Sky Spring Flow", player))
+    set_rule(multiworld.get_location("Tower of Suffer Hidden Wingboots", player), lambda state: 
+             state.has("Deluge", player) or
+             state.has("Progressive Sword", player, 2))
+    set_rule(multiworld.get_location("Misty House", player), lambda state: state.has("Black Onyx", player))
+    set_rule(multiworld.get_location("Misty Doctor Office", player), lambda state: has_any_magic(state, player))
+    set_rule(multiworld.get_location("Conflate Guru", player), lambda state: state.has("Progressive Armor", player, 3))
+    set_rule(multiworld.get_location("Branches Hidden Mattock", player), lambda state: state.has("Unlock Wingboots", player))
+    set_rule(multiworld.get_location("Path to Daybreak Glove", player), lambda state: state.has("Unlock Wingboots", player))
+    set_rule(multiworld.get_location("Dartmoor Castle Hidden Hourglass", player), lambda state: state.has("Unlock Wingboots", player))
+    set_rule(multiworld.get_location("Dartmoor Castle Hidden Red Potion", player), lambda state: has_any_magic(state, player))
+    set_rule(multiworld.get_location("Fraternal Castle Guru", player), lambda state: state.has("Progressive Sword", player, 4))
+    set_rule(multiworld.get_location("Fraternal Castle Shop Hidden Ointment", player), lambda state: has_any_magic(state, player))
+
+    if faxanadu_world.options.require_dragon_slayer.value:
+        set_rule(multiworld.get_location("Evil One", player), lambda state: 
+                 state.has_all_counts({"Progressive Sword": 4, "Progressive Armor": 3, "Progressive Shield": 4}, player))
diff --git a/worlds/faxanadu/__init__.py b/worlds/faxanadu/__init__.py
new file mode 100644
index 000000000000..c4ae1ccaa198
--- /dev/null
+++ b/worlds/faxanadu/__init__.py
@@ -0,0 +1,190 @@
+from typing import Any, Dict, List
+
+from BaseClasses import Item, Location, Tutorial, ItemClassification, MultiWorld
+from worlds.AutoWorld import WebWorld, World
+from . import Items, Locations, Regions, Rules
+from .Options import FaxanaduOptions
+from worlds.generic.Rules import set_rule
+
+
+DAXANADU_VERSION = "0.3.0"
+
+
+class FaxanaduLocation(Location):
+    game: str = "Faxanadu"
+
+
+class FaxanaduItem(Item):
+    game: str = "Faxanadu"
+
+
+class FaxanaduWeb(WebWorld):
+    tutorials = [Tutorial(
+        "Multiworld Setup Guide",
+        "A guide to setting up the Faxanadu randomizer connected to an Archipelago Multiworld",
+        "English",
+        "setup_en.md",
+        "setup/en",
+        ["Daivuk"]
+    )]
+    theme = "dirt"
+
+
+class FaxanaduWorld(World):
+    """
+    Faxanadu is an action role-playing platform video game developed by Hudson Soft for the Nintendo Entertainment System
+    """
+    options_dataclass = FaxanaduOptions
+    options: FaxanaduOptions
+    game = "Faxanadu"
+    web = FaxanaduWeb()
+
+    item_name_to_id = {item.name: item.id for item in Items.items if item.id is not None}
+    item_name_to_item = {item.name: item for item in Items.items}
+    location_name_to_id = {loc.name: loc.id for loc in Locations.locations if loc.id is not None}
+
+    def __init__(self, world: MultiWorld, player: int):
+        self.filler_ratios: Dict[str, int] = {}
+        
+        super().__init__(world, player)
+
+    def create_regions(self):
+        Regions.create_regions(self)
+
+        # Add locations into regions
+        for region in self.multiworld.get_regions(self.player):
+            for loc in [location for location in Locations.locations if location.region == region.name]:
+                location = FaxanaduLocation(self.player, loc.name, loc.id, region)
+
+                # In Faxanadu, Poison hurts you when picked up. It makes no sense to sell them in shops
+                if loc.type == Locations.LocationType.shop:
+                    location.item_rule = lambda item, player=self.player: not (player == item.player and item.name == "Poison")
+                
+                region.locations.append(location)
+
+    def set_rules(self):
+        Rules.set_rules(self)
+        self.multiworld.completion_condition[self.player] = lambda state: state.has("Killed Evil One", self.player)
+
+    def create_item(self, name: str) -> FaxanaduItem:
+        item: Items.ItemDef = self.item_name_to_item[name]
+        return FaxanaduItem(name, item.classification, item.id, self.player)
+
+    # Returns how many red potions were prefilled into shops
+    def prefill_shop_red_potions(self) -> int:
+        red_potion_in_shop_count = 0
+        if self.options.keep_shop_red_potions:
+            red_potion_item = self.item_name_to_item["Red Potion"]
+            red_potion_shop_locations = [
+                loc
+                for loc in Locations.locations
+                if loc.type == Locations.LocationType.shop and loc.original_item == Locations.ItemType.red_potion
+            ]
+            for loc in red_potion_shop_locations:
+                location = self.get_location(loc.name)
+                location.place_locked_item(FaxanaduItem(red_potion_item.name, red_potion_item.classification, red_potion_item.id, self.player))
+                red_potion_in_shop_count += 1
+        return red_potion_in_shop_count
+
+    def put_wingboot_in_shop(self, shops, region_name):
+        item = self.item_name_to_item["Wingboots"]
+        shop = shops.pop(region_name)
+        slot = self.random.randint(0, len(shop) - 1)
+        loc = shop[slot]
+        location = self.get_location(loc.name)
+        location.place_locked_item(FaxanaduItem(item.name, item.classification, item.id, self.player))
+
+        # Put a rule right away that we need to have to unlocked.
+        set_rule(location, lambda state: state.has("Unlock Wingboots", self.player))
+
+    # Returns how many wingboots were prefilled into shops
+    def prefill_shop_wingboots(self) -> int:
+        # Collect shops
+        shops: Dict[str, List[Locations.LocationDef]] = {}
+        for loc in Locations.locations:
+            if loc.type == Locations.LocationType.shop:
+                if self.options.keep_shop_red_potions and loc.original_item == Locations.ItemType.red_potion:
+                    continue # Don't override our red potions
+                shops.setdefault(loc.region, []).append(loc)
+        
+        shop_count = len(shops)
+        wingboots_count = round(shop_count / 2.5) # On 10 shops, we should have about 4 shops with wingboots
+
+        # At least one should be in the first 4 shops. Because we require wingboots to progress past that point.
+        must_have_regions = [region for i, region in enumerate(shops) if i < 4]
+        self.put_wingboot_in_shop(shops, self.random.choice(must_have_regions))
+
+        # Fill in the rest randomly in remaining shops
+        for i in range(wingboots_count - 1): # -1 because we added one already
+            region = self.random.choice(list(shops.keys()))
+            self.put_wingboot_in_shop(shops, region)
+
+        return wingboots_count
+
+    def create_items(self) -> None:
+        itempool: List[FaxanaduItem] = []
+
+        # Prefill red potions in shops if option is set
+        red_potion_in_shop_count = self.prefill_shop_red_potions()
+
+        # Prefill wingboots in shops
+        wingboots_in_shop_count = self.prefill_shop_wingboots()
+
+        # Create the item pool, excluding fillers.
+        prefilled_count = red_potion_in_shop_count + wingboots_in_shop_count
+        for item in Items.items:
+            # Ignore pendant if turned off
+            if item.name == "Pendant" and not self.options.include_pendant:
+                continue
+
+            # ignore fillers for now, we will fill them later
+            if item.classification in [ItemClassification.filler, ItemClassification.trap] and \
+               item.progression_count == 0:
+                continue
+
+            prefill_loc = None
+            if item.prefill_location:
+                prefill_loc = self.get_location(item.prefill_location)
+
+            # if require dragon slayer is turned on, we need progressive shields to be progression
+            item_classification = item.classification
+            if self.options.require_dragon_slayer and item.name == "Progressive Shield":
+                item_classification = ItemClassification.progression
+
+            if prefill_loc:
+                prefill_loc.place_locked_item(FaxanaduItem(item.name, item_classification, item.id, self.player))
+                prefilled_count += 1
+            else:
+                for i in range(item.count - item.progression_count):
+                    itempool.append(FaxanaduItem(item.name, item_classification, item.id, self.player))
+                for i in range(item.progression_count):
+                    itempool.append(FaxanaduItem(item.name, ItemClassification.progression, item.id, self.player))
+
+        # Set up filler ratios
+        self.filler_ratios = {
+            item.name: item.count
+            for item in Items.items
+            if item.classification in [ItemClassification.filler, ItemClassification.trap]
+        }
+
+        # If red potions are locked in shops, remove the count from the ratio.
+        self.filler_ratios["Red Potion"] -= red_potion_in_shop_count
+
+        # Remove poisons if not desired
+        if not self.options.include_poisons:
+            self.filler_ratios["Poison"] = 0
+
+        # Randomly add fillers to the pool with ratios based on og game occurrence counts.
+        filler_count = len(Locations.locations) - len(itempool) - prefilled_count
+        for i in range(filler_count):
+            itempool.append(self.create_item(self.get_filler_item_name()))
+                
+        self.multiworld.itempool += itempool
+
+    def get_filler_item_name(self) -> str:
+        return self.random.choices(list(self.filler_ratios.keys()), weights=list(self.filler_ratios.values()))[0]
+    
+    def fill_slot_data(self) -> Dict[str, Any]:
+        slot_data = self.options.as_dict("keep_shop_red_potions", "random_musics", "random_sounds", "random_npcs", "random_monsters", "random_rewards")
+        slot_data["daxanadu_version"] = DAXANADU_VERSION
+        return slot_data
diff --git a/worlds/faxanadu/docs/en_Faxanadu.md b/worlds/faxanadu/docs/en_Faxanadu.md
new file mode 100644
index 000000000000..7f5c4ab293ce
--- /dev/null
+++ b/worlds/faxanadu/docs/en_Faxanadu.md
@@ -0,0 +1,27 @@
+# Faxanadu
+
+## Where is the settings page?
+
+The [player options page](../player-options) contains the options needed to configure your game session.
+
+## What does randomization do to this game?
+
+All game items collected in the map, shops, and boss drops are randomized.
+
+Keys are unique. Once you get the Jack Key, you can open all Jack doors; the key stays in your inventory.
+
+Wingboots are randomized across shops only. They are LOCKED and cannot be bought until you get the item that unlocks them.
+
+Normal Elixirs don't revive the tower spring. A new item, Spring Elixir, is necessary. This new item is unique.
+
+## What is the goal?
+
+The goal is to kill the Evil One.
+
+## What is a "check" in The Faxanadu?
+
+Shop items, item locations in the world, boss drops, and secret items.
+
+## What "items" can you unlock in Faxanadu?
+
+Keys, Armors, Weapons, Potions, Shields, Magics, Poisons, Gloves, etc.
diff --git a/worlds/faxanadu/docs/setup_en.md b/worlds/faxanadu/docs/setup_en.md
new file mode 100644
index 000000000000..4ff714c61393
--- /dev/null
+++ b/worlds/faxanadu/docs/setup_en.md
@@ -0,0 +1,32 @@
+# Faxanadu Randomizer Setup
+
+## Required Software
+
+- [Daxanadu](https://github.com/Daivuk/Daxanadu/releases/)
+- Faxanadu ROM, English version
+
+## Optional Software
+
+- [ArchipelagoTextClient](https://github.com/ArchipelagoMW/Archipelago/releases)
+
+## Installing Daxanadu
+1. Download [Daxanadu.zip](https://github.com/Daivuk/Daxanadu/releases/) and extract it.
+2. Copy your rom `Faxanadu (U).nes` into the newly extracted folder.
+
+## Joining a MultiWorld Game
+
+1. Launch Daxanadu.exe
+2. From the Main menu, go to the `ARCHIPELAGO` menu. Enter the server's address, slot name, and password. Then select `PLAY`.
+3. Enjoy!
+
+To continue a game, follow the same connection steps.
+Connecting with a different seed won't erase your progress in other seeds.
+
+## Archipelago Text Client
+
+We recommend having Archipelago's Text Client open on the side to keep track of what items you receive and send.
+Daxanadu doesn't display messages. You'll only get popups when picking them up.
+
+## Auto-Tracking
+
+Daxanadu has an integrated tracker that can be toggled in the options.

From 1365bd7a0ac0a130de3f383505140091ef8a0683 Mon Sep 17 00:00:00 2001
From: Kaito Sinclaire <ks@rosenthalcastle.org>
Date: Fri, 29 Nov 2024 13:46:38 -0800
Subject: [PATCH 14/20] CODEOWNERS: Add KScl as world maintainer for id Tech 1
 games (#4288)

---
 docs/CODEOWNERS | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/CODEOWNERS b/docs/CODEOWNERS
index 4b7496c686c8..64a1362bf380 100644
--- a/docs/CODEOWNERS
+++ b/docs/CODEOWNERS
@@ -55,10 +55,10 @@
 /worlds/dlcquest/ @axe-y @agilbert1412
 
 # DOOM 1993
-/worlds/doom_1993/ @Daivuk
+/worlds/doom_1993/ @Daivuk @KScl
 
 # DOOM II
-/worlds/doom_ii/ @Daivuk
+/worlds/doom_ii/ @Daivuk @KScl
 
 # Factorio
 /worlds/factorio/ @Berserker66
@@ -70,7 +70,7 @@
 /worlds/ffmq/ @Alchav @wildham0
 
 # Heretic
-/worlds/heretic/ @Daivuk
+/worlds/heretic/ @Daivuk @KScl
 
 # Hollow Knight
 /worlds/hk/ @BadMagic100 @qwint

From 7c00c9a49d4f1626c049ad132e64da2d09f5e818 Mon Sep 17 00:00:00 2001
From: palex00 <32203971+palex00@users.noreply.github.com>
Date: Fri, 29 Nov 2024 22:48:01 +0100
Subject: [PATCH 15/20] Core: Change "Unreachable Items" to "Unreachable
 progression items" in playthrough warning for clarification (#4287)

---
 BaseClasses.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/BaseClasses.py b/BaseClasses.py
index 700a21506ac8..d84da5d212b4 100644
--- a/BaseClasses.py
+++ b/BaseClasses.py
@@ -1545,7 +1545,7 @@ def write_option(option_key: str, option_obj: Options.AssembleOptions) -> None:
                 [f"  {location}: {item}" for (location, item) in sphere.items()] if isinstance(sphere, dict) else
                 [f"  {item}" for item in sphere])) for (sphere_nr, sphere) in self.playthrough.items()]))
             if self.unreachables:
-                outfile.write('\n\nUnreachable Items:\n\n')
+                outfile.write('\n\nUnreachable Progression Items:\n\n')
                 outfile.write(
                     '\n'.join(['%s: %s' % (unreachable.item, unreachable) for unreachable in self.unreachables]))
 

From b0a61be9df713e31ec874d84326d26f3d3e225ac Mon Sep 17 00:00:00 2001
From: Exempt-Medic <60412657+Exempt-Medic@users.noreply.github.com>
Date: Fri, 29 Nov 2024 16:57:35 -0500
Subject: [PATCH 16/20] Tests: Add test that local/non local items aren't
 modified late #3976

---
 test/general/test_items.py | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/test/general/test_items.py b/test/general/test_items.py
index 9cc91a1b00ef..64ce1b6997b7 100644
--- a/test/general/test_items.py
+++ b/test/general/test_items.py
@@ -80,3 +80,21 @@ def test_itempool_not_modified(self):
                         call_all(multiworld, step)
                         self.assertEqual(created_items, multiworld.itempool,
                                          f"{game_name} modified the itempool during {step}")
+
+    def test_locality_not_modified(self):
+        """Test that worlds don't modify the locality of items after duplicates are resolved"""
+        gen_steps = ("generate_early", "create_regions", "create_items")
+        additional_steps = ("set_rules", "generate_basic", "pre_fill")
+        worlds_to_test = {game: world for game, world in AutoWorldRegister.world_types.items()}
+        for game_name, world_type in worlds_to_test.items():
+            with self.subTest("Game", game=game_name):
+                multiworld = setup_solo_multiworld(world_type, gen_steps)
+                local_items = multiworld.worlds[1].options.local_items.value.copy()
+                non_local_items = multiworld.worlds[1].options.non_local_items.value.copy()
+                for step in additional_steps:
+                    with self.subTest("step", step=step):
+                        call_all(multiworld, step)
+                        self.assertEqual(local_items, multiworld.worlds[1].options.local_items.value,
+                                         f"{game_name} modified local_items during {step}")
+                        self.assertEqual(non_local_items, multiworld.worlds[1].options.non_local_items.value,
+                                         f"{game_name} modified non_local_items during {step}")

From 46dfc4d4fc00d61e89a2b3885053d003df7bae81 Mon Sep 17 00:00:00 2001
From: Aaron Wagener <mmmcheese158@gmail.com>
Date: Fri, 29 Nov 2024 16:37:14 -0600
Subject: [PATCH 17/20] Core: Allow option groups to specify option order
 (#3393)

* Core: Allow option groups to specify option order

* words hard

* Actually use the earlier built dictionary for faster in checking

Co-authored-by: Doug Hoskisson <beauxq@users.noreply.github.com>

---------

Co-authored-by: Doug Hoskisson <beauxq@users.noreply.github.com>
---
 Options.py | 34 +++++++++++++++++++---------------
 1 file changed, 19 insertions(+), 15 deletions(-)

diff --git a/Options.py b/Options.py
index d81f81face06..0d0e6ae1cd95 100644
--- a/Options.py
+++ b/Options.py
@@ -1463,22 +1463,26 @@ class OptionGroup(typing.NamedTuple):
 def get_option_groups(world: typing.Type[World], visibility_level: Visibility = Visibility.template) -> typing.Dict[
         str, typing.Dict[str, typing.Type[Option[typing.Any]]]]:
     """Generates and returns a dictionary for the option groups of a specified world."""
-    option_groups = {option: option_group.name
-                     for option_group in world.web.option_groups
-                     for option in option_group.options}
+    option_to_name = {option: option_name for option_name, option in world.options_dataclass.type_hints.items()}
+
+    ordered_groups = {group.name: group.options for group in world.web.option_groups}
+
     # add a default option group for uncategorized options to get thrown into
-    ordered_groups = ["Game Options"]
-    [ordered_groups.append(group) for group in option_groups.values() if group not in ordered_groups]
-    grouped_options = {group: {} for group in ordered_groups}
-    for option_name, option in world.options_dataclass.type_hints.items():
-        if visibility_level & option.visibility:
-            grouped_options[option_groups.get(option, "Game Options")][option_name] = option
-
-    # if the world doesn't have any ungrouped options, this group will be empty so just remove it
-    if not grouped_options["Game Options"]:
-        del grouped_options["Game Options"]
-
-    return grouped_options
+    if "Game Options" not in ordered_groups:
+        grouped_options = set(option for group in ordered_groups.values() for option in group)
+        ungrouped_options = [option for option in option_to_name if option not in grouped_options]
+        # only add the game options group if we have ungrouped options
+        if ungrouped_options:
+            ordered_groups = {**{"Game Options": ungrouped_options}, **ordered_groups}
+
+    return {
+        group: {
+            option_to_name[option]: option
+            for option in group_options
+            if (visibility_level in option.visibility and option in option_to_name)
+        }
+        for group, group_options in ordered_groups.items()
+    }
 
 
 def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], generate_hidden: bool = True) -> None:

From dd88b2c6581e9f5db97dc3601086637f34c52b5f Mon Sep 17 00:00:00 2001
From: NewSoupVi <57900059+NewSoupVi@users.noreply.github.com>
Date: Fri, 29 Nov 2024 23:47:27 +0100
Subject: [PATCH 18/20] The Witness: Fix unreachable locations on Longbox +
 Postgame #4291

---
 worlds/witness/player_logic.py                 | 2 +-
 worlds/witness/test/test_roll_other_options.py | 7 +++++++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/worlds/witness/player_logic.py b/worlds/witness/player_logic.py
index ec4ea066e579..58f15532f58c 100644
--- a/worlds/witness/player_logic.py
+++ b/worlds/witness/player_logic.py
@@ -984,7 +984,7 @@ def make_event_panel_lists(self) -> None:
         Makes event-item pairs for entities with associated events, unless these entities are disabled.
         """
 
-        self.ALWAYS_EVENT_NAMES_BY_HEX[self.VICTORY_LOCATION] = "Victory"
+        self.USED_EVENT_NAMES_BY_HEX[self.VICTORY_LOCATION].append("Victory")
 
         for event_hex, event_name in self.ALWAYS_EVENT_NAMES_BY_HEX.items():
             self.USED_EVENT_NAMES_BY_HEX[event_hex].append(event_name)
diff --git a/worlds/witness/test/test_roll_other_options.py b/worlds/witness/test/test_roll_other_options.py
index 0429b097eac3..05f3235a1f4d 100644
--- a/worlds/witness/test/test_roll_other_options.py
+++ b/worlds/witness/test/test_roll_other_options.py
@@ -62,3 +62,10 @@ class TestPostgameGroupedDoors(WitnessTestBase):
         "door_groupings": "regional",
         "victory_condition": "elevator",
     }
+
+
+class TestPostgamePanels(WitnessTestBase):
+    options = {
+        "victory_condition": "mountain_box_long",
+        "shuffle_postgame": True
+    }

From 1487d323cd165270c85ebf938b47cf1726a33900 Mon Sep 17 00:00:00 2001
From: qwint <qwint.42@gmail.com>
Date: Fri, 29 Nov 2024 18:01:24 -0500
Subject: [PATCH 19/20] Core: update error message for mismatched "event"
 placements #4043

---
 Main.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Main.py b/Main.py
index 606514630f0d..b9612e9549ba 100644
--- a/Main.py
+++ b/Main.py
@@ -282,7 +282,7 @@ def precollect_hint(location):
                     if type(location.address) == int:
                         assert location.item.code is not None, "item code None should be event, " \
                                                                "location.address should then also be None. Location: " \
-                                                               f" {location}"
+                                                               f" {location}, Item: {location.item}"
                         assert location.address not in locations_data[location.player], (
                             f"Locations with duplicate address. {location} and "
                             f"{locations_data[location.player][location.address]}")

From 492e3a355e5f9ec341e3b27fc522372374de1cea Mon Sep 17 00:00:00 2001
From: Fabian Dill <Berserker66@users.noreply.github.com>
Date: Sat, 30 Nov 2024 00:37:26 +0100
Subject: [PATCH 20/20] WebHost: delete unused script tag (#4062)

---
 WebHostLib/templates/templates.html | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/WebHostLib/templates/templates.html b/WebHostLib/templates/templates.html
index fb6ea7e9eab5..3b2418ae15b6 100644
--- a/WebHostLib/templates/templates.html
+++ b/WebHostLib/templates/templates.html
@@ -4,9 +4,6 @@
     {% include 'header/grassHeader.html' %}
     <title>Option Templates (YAML)</title>
     <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/markdown.css") }}" />
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/showdown/1.9.1/showdown.min.js"
-            integrity="sha512-L03kznCrNOfVxOUovR6ESfCz9Gfny7gihUX/huVbQB9zjODtYpxaVtIaAkpetoiyV2eqWbvxMH9fiSv5enX7bw=="
-            crossorigin="anonymous"></script>
 {% endblock %}
 
 {% block body %}