The Witness: Move the Easter Egg Hunt option group lower so that the tooltip isn't cut off

* Fix some unrandomized locations on specific settings.

* Remove now-unnecessary comment

.github/pyright-config.json

@@ -2,6 +2,7 @@
   "include": [
     "../BizHawkClient.py",
     "../Patch.py",
+    "../test/param.py",
     "../test/general/test_groups.py",
     "../test/general/test_helpers.py",
     "../test/general/test_memory.py",

.github/workflows/build.yml

@@ -132,7 +132,7 @@ jobs:
           # charset-normalizer was somehow incomplete in the github runner
           "${{ env.PYTHON }}" -m venv venv
           source venv/bin/activate
-          "${{ env.PYTHON }}" -m pip install --upgrade pip PyGObject charset-normalizer
+          "${{ env.PYTHON }}" -m pip install --upgrade pip "PyGObject<3.51.0" charset-normalizer
           python setup.py build_exe --yes bdist_appimage --yes
           echo -e "setup.py build output:\n `ls build`"
           echo -e "setup.py dist output:\n `ls dist`"

.github/workflows/ctest.yml

@@ -11,7 +11,7 @@ on:
       - '**.hh?'
       - '**.hpp'
       - '**.hxx'
-      - '**.CMakeLists'
+      - '**/CMakeLists.txt'
       - '.github/workflows/ctest.yml'
   pull_request:
     paths:
@@ -21,7 +21,7 @@ on:
       - '**.hh?'
       - '**.hpp'
       - '**.hxx'
-      - '**.CMakeLists'
+      - '**/CMakeLists.txt'
       - '.github/workflows/ctest.yml'
 
 jobs:
@@ -36,9 +36,9 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
-    - uses: ilammy/msvc-dev-cmd@v1
+    - uses: ilammy/msvc-dev-cmd@0b201ec74fa43914dc39ae48a89fd1d8cb592756
       if: startsWith(matrix.os,'windows')
-    - uses: Bacondish2023/setup-googletest@v1
+    - uses: Bacondish2023/setup-googletest@49065d1f7a6d21f6134864dd65980fe5dbe06c73
       with:
         build-type: 'Release'
     - name: Build tests

.github/workflows/release.yml

@@ -64,7 +64,7 @@ jobs:
           # charset-normalizer was somehow incomplete in the github runner
           "${{ env.PYTHON }}" -m venv venv
           source venv/bin/activate
-          "${{ env.PYTHON }}" -m pip install --upgrade pip PyGObject charset-normalizer
+          "${{ env.PYTHON }}" -m pip install --upgrade pip "PyGObject<3.51.0" charset-normalizer
           python setup.py build_exe --yes bdist_appimage --yes
           echo -e "setup.py build output:\n `ls build`"
           echo -e "setup.py dist output:\n `ls dist`"

.gitignore

@@ -4,11 +4,13 @@
 *_Spoiler.txt
 *.bmbp
 *.apbp
+*.apcivvi
 *.apl2ac
 *.apm3
 *.apmc
 *.apz5
 *.aptloz
+*.aptww
 *.apemerald
 *.pyc
 *.pyd

AdventureClient.py

@@ -511,7 +511,7 @@ if __name__ == '__main__':
 
     import colorama
 
-    colorama.init()
+    colorama.just_fix_windows_console()
 
     asyncio.run(main())
     colorama.deinit()

BaseClasses.py

@@ -869,21 +869,40 @@ class CollectionState():
     def has(self, item: str, player: int, count: int = 1) -> bool:
         return self.prog_items[player][item] >= count
 
+    # for loops are specifically used in all/any/count methods, instead of all()/any()/sum(), to avoid the overhead of
+    # creating and iterating generator instances. In `return all(player_prog_items[item] for item in items)`, the
+    # argument to all() would be a new generator instance, for example.
     def has_all(self, items: Iterable[str], player: int) -> bool:
         """Returns True if each item name of items is in state at least once."""
-        return all(self.prog_items[player][item] for item in items)
+        player_prog_items = self.prog_items[player]
+        for item in items:
+            if not player_prog_items[item]:
+                return False
+        return True
 
     def has_any(self, items: Iterable[str], player: int) -> bool:
         """Returns True if at least one item name of items is in state at least once."""
-        return any(self.prog_items[player][item] for item in items)
+        player_prog_items = self.prog_items[player]
+        for item in items:
+            if player_prog_items[item]:
+                return True
+        return False
 
     def has_all_counts(self, item_counts: Mapping[str, int], player: int) -> bool:
         """Returns True if each item name is in the state at least as many times as specified."""
-        return all(self.prog_items[player][item] >= count for item, count in item_counts.items())
+        player_prog_items = self.prog_items[player]
+        for item, count in item_counts.items():
+            if player_prog_items[item] < count:
+                return False
+        return True
 
     def has_any_count(self, item_counts: Mapping[str, int], player: int) -> bool:
         """Returns True if at least one item name is in the state at least as many times as specified."""
-        return any(self.prog_items[player][item] >= count for item, count in item_counts.items())
+        player_prog_items = self.prog_items[player]
+        for item, count in item_counts.items():
+            if player_prog_items[item] >= count:
+                return True
+        return False
 
     def count(self, item: str, player: int) -> int:
         return self.prog_items[player][item]
@@ -911,11 +930,20 @@ class CollectionState():
 
     def count_from_list(self, items: Iterable[str], player: int) -> int:
         """Returns the cumulative count of items from a list present in state."""
-        return sum(self.prog_items[player][item_name] for item_name in items)
+        player_prog_items = self.prog_items[player]
+        total = 0
+        for item_name in items:
+            total += player_prog_items[item_name]
+        return total
 
     def count_from_list_unique(self, items: Iterable[str], player: int) -> int:
         """Returns the cumulative count of items from a list present in state. Ignores duplicates of the same item."""
-        return sum(self.prog_items[player][item_name] > 0 for item_name in items)
+        player_prog_items = self.prog_items[player]
+        total = 0
+        for item_name in items:
+            if player_prog_items[item_name] > 0:
+                total += 1
+        return total
 
     # item name group related
     def has_group(self, item_name_group: str, player: int, count: int = 1) -> bool:

CommonClient.py

@@ -709,8 +709,16 @@ class CommonContext:
         logger.exception(msg, exc_info=exc_info, extra={'compact_gui': True})
         self._messagebox_connection_loss = self.gui_error(msg, exc_info[1])
 
-    def make_gui(self) -> typing.Type["kvui.GameManager"]:
-        """To return the Kivy App class needed for run_gui so it can be overridden before being built"""
+    def make_gui(self) -> "type[kvui.GameManager]":
+        """
+        To return the Kivy `App` class needed for `run_gui` so it can be overridden before being built
+
+        Common changes are changing `base_title` to update the window title of the client and
+        updating `logging_pairs` to automatically make new tabs that can be filled with their respective logger.
+
+        ex. `logging_pairs.append(("Foo", "Bar"))`
+        will add a "Bar" tab which follows the logger returned from `logging.getLogger("Foo")`
+        """
         from kvui import GameManager
 
         class TextManager(GameManager):
@@ -899,6 +907,7 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
             ctx.disconnected_intentionally = True
             ctx.event_invalid_game()
         elif 'IncompatibleVersion' in errors:
+            ctx.disconnected_intentionally = True
             raise Exception('Server reported your client version as incompatible. '
                             'This probably means you have to update.')
         elif 'InvalidItemsHandling' in errors:
@@ -1087,7 +1096,7 @@ def run_as_textclient(*args):
             if password_requested and not self.password:
                 await super(TextContext, self).server_auth(password_requested)
             await self.get_username()
-            await self.send_connect()
+            await self.send_connect(game="")
 
         def on_package(self, cmd: str, args: dict):
             if cmd == "Connected":
@@ -1119,7 +1128,7 @@ def run_as_textclient(*args):
     args = handle_url_arg(args, parser=parser)
 
     # use colorama to display colored text highlighting on windows
-    colorama.init()
+    colorama.just_fix_windows_console()
 
     asyncio.run(main(args))
     colorama.deinit()

FF1Client.py

@@ -261,7 +261,7 @@ if __name__ == '__main__':
 
     parser = get_base_parser()
     args = parser.parse_args()
-    colorama.init()
+    colorama.just_fix_windows_console()
 
     asyncio.run(main(args))
     colorama.deinit()

Fill.py

@@ -502,7 +502,13 @@ def distribute_items_restrictive(multiworld: MultiWorld,
         # "priority fill"
         fill_restrictive(multiworld, multiworld.state, prioritylocations, progitempool,
                          single_player_placement=single_player, swap=False, on_place=mark_for_locking,
-                         name="Priority", one_item_per_player=False)
+                         name="Priority", one_item_per_player=True, allow_partial=True)
+
+        if prioritylocations:
+            # retry with one_item_per_player off because some priority fills can fail to fill with that optimization
+            fill_restrictive(multiworld, multiworld.state, prioritylocations, progitempool,
+                            single_player_placement=single_player, swap=False, on_place=mark_for_locking,
+                            name="Priority Retry", one_item_per_player=False)
         accessibility_corrections(multiworld, multiworld.state, prioritylocations, progitempool)
         defaultlocations = prioritylocations + defaultlocations
 

LinksAwakeningClient.py

@@ -28,6 +28,7 @@ from CommonClient import (CommonContext, get_base_parser, gui_enabled, logger,
 from NetUtils import ClientStatus
 from worlds.ladx.Common import BASE_ID as LABaseID
 from worlds.ladx.GpsTracker import GpsTracker
+from worlds.ladx.TrackerConsts import storage_key
 from worlds.ladx.ItemTracker import ItemTracker
 from worlds.ladx.LADXR.checkMetadata import checkMetadataTable
 from worlds.ladx.Locations import get_locations_to_id, meta_to_name
@@ -100,19 +101,23 @@ class LAClientConstants:
     WRamCheckSize = 0x4
     WRamSafetyValue = bytearray([0]*WRamCheckSize)
 
+    wRamStart = 0xC000
+    hRamStart = 0xFF80
+    hRamSize = 0x80
+
     MinGameplayValue = 0x06
     MaxGameplayValue = 0x1A
     VictoryGameplayAndSub = 0x0102
 
-
 class RAGameboy():
     cache = []
-    cache_start = 0
-    cache_size = 0
     last_cache_read = None
     socket = None
 
     def __init__(self, address, port) -> None:
+        self.cache_start = LAClientConstants.wRamStart
+        self.cache_size = LAClientConstants.hRamStart + LAClientConstants.hRamSize - LAClientConstants.wRamStart
+
         self.address = address
         self.port = port
         self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
@@ -131,9 +136,14 @@ class RAGameboy():
     async def get_retroarch_status(self):
         return await self.send_command("GET_STATUS")
 
-    def set_cache_limits(self, cache_start, cache_size):
-        self.cache_start = cache_start
-        self.cache_size = cache_size
+    def set_checks_range(self, checks_start, checks_size):
+        self.checks_start = checks_start
+        self.checks_size = checks_size
+    
+    def set_location_range(self, location_start, location_size, critical_addresses):
+        self.location_start = location_start
+        self.location_size = location_size
+        self.critical_location_addresses = critical_addresses
 
     def send(self, b):
         if type(b) is str:
@@ -188,21 +198,57 @@ class RAGameboy():
         if not await self.check_safe_gameplay():
             return
 
-        cache = []
-        remaining_size = self.cache_size
-        while remaining_size:
-            block = await self.async_read_memory(self.cache_start + len(cache), remaining_size)
-            remaining_size -= len(block)
-            cache += block
+        attempts = 0
+        while True:
+            # RA doesn't let us do an atomic read of a large enough block of RAM
+            # Some bytes can't change in between reading location_block and hram_block
+            location_block = await self.read_memory_block(self.location_start, self.location_size)
+            hram_block = await self.read_memory_block(LAClientConstants.hRamStart, LAClientConstants.hRamSize)
+            verification_block = await self.read_memory_block(self.location_start, self.location_size)
+
+            valid = True
+            for address in self.critical_location_addresses:
+                if location_block[address - self.location_start] != verification_block[address - self.location_start]:
+                    valid = False
+
+            if valid:
+                break
+
+            attempts += 1
+
+            # Shouldn't really happen, but keep it from choking
+            if attempts > 5:
+                return
+
+        checks_block = await self.read_memory_block(self.checks_start, self.checks_size)
 
         if not await self.check_safe_gameplay():
             return
 
-        self.cache = cache
+        self.cache = bytearray(self.cache_size)
+
+        start = self.checks_start - self.cache_start
+        self.cache[start:start + len(checks_block)] = checks_block
+
+        start = self.location_start - self.cache_start
+        self.cache[start:start + len(location_block)] = location_block
+
+        start = LAClientConstants.hRamStart - self.cache_start
+        self.cache[start:start + len(hram_block)] = hram_block
+
         self.last_cache_read = time.time()
+    
+    async def read_memory_block(self, address: int, size: int):
+        block = bytearray()
+        remaining_size = size
+        while remaining_size:
+            chunk = await self.async_read_memory(address + len(block), remaining_size)
+            remaining_size -= len(chunk)
+            block += chunk
+        
+        return block
 
     async def read_memory_cache(self, addresses):
-        # TODO: can we just update once per frame?
         if not self.last_cache_read or self.last_cache_read + 0.1 < time.time():
             await self.update_cache()
         if not self.cache:
@@ -359,11 +405,12 @@ class LinksAwakeningClient():
         auth = binascii.hexlify(await self.gameboy.async_read_memory(0x0134, 12)).decode()
         self.auth = auth
 
-    async def wait_and_init_tracker(self):
+    async def wait_and_init_tracker(self, magpie: MagpieBridge):
         await self.wait_for_game_ready()
         self.tracker = LocationTracker(self.gameboy)
         self.item_tracker = ItemTracker(self.gameboy)
         self.gps_tracker = GpsTracker(self.gameboy)
+        magpie.gps_tracker = self.gps_tracker
 
     async def recved_item_from_ap(self, item_id, from_player, next_index):
         # Don't allow getting an item until you've got your first check
@@ -405,9 +452,11 @@ class LinksAwakeningClient():
         return (await self.gameboy.read_memory_cache([LAClientConstants.wGameplayType]))[LAClientConstants.wGameplayType] == 1
 
     async def main_tick(self, item_get_cb, win_cb, deathlink_cb):
+        await self.gameboy.update_cache()
         await self.tracker.readChecks(item_get_cb)
         await self.item_tracker.readItems()
         await self.gps_tracker.read_location()
+        await self.gps_tracker.read_entrances()
 
         current_health = (await self.gameboy.read_memory_cache([LAClientConstants.wLinkHealth]))[LAClientConstants.wLinkHealth]
         if self.deathlink_debounce and current_health != 0:
@@ -457,7 +506,7 @@ class LinksAwakeningContext(CommonContext):
     la_task = None
     client = None
     # TODO: does this need to re-read on reset?
-    found_checks = []
+    found_checks = set()
     last_resend = time.time()
 
     magpie_enabled = False
@@ -465,6 +514,10 @@ class LinksAwakeningContext(CommonContext):
     magpie_task = None
     won = False
 
+    @property 
+    def slot_storage_key(self): 
+        return f"{self.slot_info[self.slot].name}_{storage_key}"
+
     def __init__(self, server_address: typing.Optional[str], password: typing.Optional[str], magpie: typing.Optional[bool]) -> None:
         self.client = LinksAwakeningClient()
         self.slot_data = {}
@@ -505,9 +558,17 @@ class LinksAwakeningContext(CommonContext):
 
         self.ui = LADXManager(self)
         self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
+    
+    async def send_new_entrances(self, entrances: typing.Dict[str, str]):
+        # Store the entrances we find on the server for future sessions
+        message = [{
+            "cmd": "Set",
+            "key": self.slot_storage_key,
+            "default": {},
+            "want_reply": False,
+            "operations": [{"operation": "update", "value": entrances}],
+        }]
 
-    async def send_checks(self):
-        message = [{"cmd": 'LocationChecks', "locations": self.found_checks}]
         await self.send_msgs(message)
 
     had_invalid_slot_data = None
@@ -536,14 +597,20 @@ class LinksAwakeningContext(CommonContext):
             logger.info("victory!")
             await self.send_msgs(message)
             self.won = True
+    
+    async def request_found_entrances(self):
+        await self.send_msgs([{"cmd": "Get", "keys": [self.slot_storage_key]}])
+
+        # Ask for updates so that players can co-op entrances in a seed  
+        await self.send_msgs([{"cmd": "SetNotify", "keys": [self.slot_storage_key]}])  
 
     async def on_deathlink(self, data: typing.Dict[str, typing.Any]) -> None:
         if self.ENABLE_DEATHLINK:
             self.client.pending_deathlink = True
 
     def new_checks(self, item_ids, ladxr_ids):
-        self.found_checks += item_ids
-        create_task_log_exception(self.send_checks())
+        self.found_checks.update(item_ids)
+        create_task_log_exception(self.check_locations(self.found_checks))
         if self.magpie_enabled:
             create_task_log_exception(self.magpie.send_new_checks(ladxr_ids))
 
@@ -576,6 +643,12 @@ class LinksAwakeningContext(CommonContext):
         if cmd == "ReceivedItems":
             for index, item in enumerate(args["items"], start=args["index"]):
                 self.client.recvd_checks[index] = item
+        
+        if cmd == "Retrieved" and self.magpie_enabled and self.slot_storage_key in args["keys"]:
+            self.client.gps_tracker.receive_found_entrances(args["keys"][self.slot_storage_key])
+
+        if cmd == "SetReply" and self.magpie_enabled and args["key"] == self.slot_storage_key:
+            self.client.gps_tracker.receive_found_entrances(args["value"])
 
     async def sync(self):
         sync_msg = [{'cmd': 'Sync'}]
@@ -589,6 +662,12 @@ class LinksAwakeningContext(CommonContext):
                 checkMetadataTable[check.id])] for check in ladxr_checks]
             self.new_checks(checks, [check.id for check in ladxr_checks])
 
+            for check in ladxr_checks:
+                if check.value and check.linkedItem:
+                    linkedItem = check.linkedItem
+                    if 'condition' not in linkedItem or linkedItem['condition'](self.slot_data):
+                        self.client.item_tracker.setExtraItem(check.linkedItem['item'], check.linkedItem['qty'])
+
         async def victory():
             await self.send_victory()
 
@@ -622,21 +701,36 @@ class LinksAwakeningContext(CommonContext):
                 if not self.client.recvd_checks:
                     await self.sync()
 
-                await self.client.wait_and_init_tracker()
+                await self.client.wait_and_init_tracker(self.magpie)
 
+                min_tick_duration = 0.1
+                last_tick = time.time()
                 while True:
                     await self.client.main_tick(on_item_get, victory, deathlink)
-                    await asyncio.sleep(0.1)
+
                     now = time.time()
+                    tick_duration = now - last_tick
+                    sleep_duration = max(min_tick_duration - tick_duration, 0)
+                    await asyncio.sleep(sleep_duration)
+
+                    last_tick = now
+
                     if self.last_resend + 5.0 < now:
                         self.last_resend = now
-                        await self.send_checks()
+                        await self.check_locations(self.found_checks)
                     if self.magpie_enabled:
                         try:
                             self.magpie.set_checks(self.client.tracker.all_checks)
                             await self.magpie.set_item_tracker(self.client.item_tracker)
-                            await self.magpie.send_gps(self.client.gps_tracker)
                             self.magpie.slot_data = self.slot_data
+                            
+                            if self.client.gps_tracker.needs_found_entrances:
+                                await self.request_found_entrances()
+                                self.client.gps_tracker.needs_found_entrances = False
+
+                            new_entrances = await self.magpie.send_gps(self.client.gps_tracker)
+                            if new_entrances:
+                                await self.send_new_entrances(new_entrances)
                         except Exception:
                             # Don't let magpie errors take out the client
                             pass
@@ -705,6 +799,6 @@ async def main():
     await ctx.shutdown()
 
 if __name__ == '__main__':
-    colorama.init()
+    colorama.just_fix_windows_console()
     asyncio.run(main())
     colorama.deinit()

LttPAdjuster.py

@@ -33,10 +33,15 @@ WINDOW_MIN_HEIGHT = 525
 WINDOW_MIN_WIDTH = 425
 
 class AdjusterWorld(object):
+    class AdjusterSubWorld(object):
+        def __init__(self, random):
+            self.random = random
+
     def __init__(self, sprite_pool):
         import random
         self.sprite_pool = {1: sprite_pool}
         self.per_slot_randoms = {1: random}
+        self.worlds = {1: self.AdjusterSubWorld(random)}
 
 
 class ArgumentDefaultsHelpFormatter(argparse.RawTextHelpFormatter):

MMBN3Client.py

@@ -370,7 +370,7 @@ if __name__ == "__main__":
 
     import colorama
 
-    colorama.init()
+    colorama.just_fix_windows_console()
 
     asyncio.run(main())
     colorama.deinit()

Main.py

@@ -148,7 +148,8 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
     else:
         multiworld.worlds[1].options.non_local_items.value = set()
         multiworld.worlds[1].options.local_items.value = set()
-    
+
+    AutoWorld.call_all(multiworld, "connect_entrances")
     AutoWorld.call_all(multiworld, "generate_basic")
 
     # remove starting inventory from pool items.

MultiServer.py

@@ -28,9 +28,11 @@ ModuleUpdate.update()
 
 if typing.TYPE_CHECKING:
     import ssl
+    from NetUtils import ServerConnection
 
-import websockets
 import colorama
+import websockets
+from websockets.extensions.permessage_deflate import PerMessageDeflate
 try:
     # ponyorm is a requirement for webhost, not default server, so may not be importable
     from pony.orm.dbapiprovider import OperationalError
@@ -45,7 +47,7 @@ from NetUtils import Endpoint, ClientStatus, NetworkItem, decode, encode, Networ
 from BaseClasses import ItemClassification
 
 min_client_version = Version(0, 1, 6)
-colorama.init()
+colorama.just_fix_windows_console()
 
 
 def remove_from_list(container, value):
@@ -119,13 +121,14 @@ def get_saving_second(seed_name: str, interval: int = 60) -> int:
 
 class Client(Endpoint):
     version = Version(0, 0, 0)
-    tags: typing.List[str] = []
+    tags: typing.List[str]
     remote_items: bool
     remote_start_inventory: bool
     no_items: bool
     no_locations: bool
+    no_text: bool
 
-    def __init__(self, socket: websockets.WebSocketServerProtocol, ctx: Context):
+    def __init__(self, socket: "ServerConnection", ctx: Context) -> None:
         super().__init__(socket)
         self.auth = False
         self.team = None
@@ -175,6 +178,7 @@ class Context:
                       "compatibility": int}
     # team -> slot id -> list of clients authenticated to slot.
     clients: typing.Dict[int, typing.Dict[int, typing.List[Client]]]
+    endpoints: list[Client]
     locations: LocationStore  # typing.Dict[int, typing.Dict[int, typing.Tuple[int, int, int]]]
     location_checks: typing.Dict[typing.Tuple[int, int], typing.Set[int]]
     hints_used: typing.Dict[typing.Tuple[int, int], int]
@@ -364,18 +368,28 @@ class Context:
             return True
 
     def broadcast_all(self, msgs: typing.List[dict]):
-        msgs = self.dumper(msgs)
-        endpoints = (endpoint for endpoint in self.endpoints if endpoint.auth)
-        async_start(self.broadcast_send_encoded_msgs(endpoints, msgs))
+        msg_is_text = all(msg["cmd"] == "PrintJSON" for msg in msgs)
+        data = self.dumper(msgs)
+        endpoints = (
+            endpoint
+            for endpoint in self.endpoints
+            if endpoint.auth and not (msg_is_text and endpoint.no_text)
+        )
+        async_start(self.broadcast_send_encoded_msgs(endpoints, data))
 
     def broadcast_text_all(self, text: str, additional_arguments: dict = {}):
         self.logger.info("Notice (all): %s" % text)
         self.broadcast_all([{**{"cmd": "PrintJSON", "data": [{ "text": text }]}, **additional_arguments}])
 
     def broadcast_team(self, team: int, msgs: typing.List[dict]):
-        msgs = self.dumper(msgs)
-        endpoints = (endpoint for endpoint in itertools.chain.from_iterable(self.clients[team].values()))
-        async_start(self.broadcast_send_encoded_msgs(endpoints, msgs))
+        msg_is_text = all(msg["cmd"] == "PrintJSON" for msg in msgs)
+        data = self.dumper(msgs)
+        endpoints = (
+            endpoint
+            for endpoint in itertools.chain.from_iterable(self.clients[team].values())
+            if not (msg_is_text and endpoint.no_text)
+        )
+        async_start(self.broadcast_send_encoded_msgs(endpoints, data))
 
     def broadcast(self, endpoints: typing.Iterable[Client], msgs: typing.List[dict]):
         msgs = self.dumper(msgs)
@@ -389,13 +403,13 @@ class Context:
         await on_client_disconnected(self, endpoint)
 
     def notify_client(self, client: Client, text: str, additional_arguments: dict = {}):
-        if not client.auth:
+        if not client.auth or client.no_text:
             return
         self.logger.info("Notice (Player %s in team %d): %s" % (client.name, client.team + 1, text))
         async_start(self.send_msgs(client, [{"cmd": "PrintJSON", "data": [{ "text": text }], **additional_arguments}]))
 
     def notify_client_multiple(self, client: Client, texts: typing.List[str], additional_arguments: dict = {}):
-        if not client.auth:
+        if not client.auth or client.no_text:
             return
         async_start(self.send_msgs(client,
                                    [{"cmd": "PrintJSON", "data": [{ "text": text }], **additional_arguments}
@@ -760,7 +774,7 @@ class Context:
             self.on_new_hint(team, slot)
         for slot, hint_data in concerns.items():
             if recipients is None or slot in recipients:
-                clients = self.clients[team].get(slot)
+                clients = filter(lambda c: not c.no_text, self.clients[team].get(slot, []))
                 if not clients:
                     continue
                 client_hints = [datum[1] for datum in sorted(hint_data, key=lambda x: x[0].finding_player != slot)]
@@ -769,7 +783,7 @@ class Context:
 
     def get_hint(self, team: int, finding_player: int, seeked_location: int) -> typing.Optional[Hint]:
         for hint in self.hints[team, finding_player]:
-            if hint.location == seeked_location:
+            if hint.location == seeked_location and hint.finding_player == finding_player:
                 return hint
         return None
     
@@ -819,7 +833,7 @@ def update_aliases(ctx: Context, team: int):
             async_start(ctx.send_encoded_msgs(client, cmd))
 
 
-async def server(websocket, path: str = "/", ctx: Context = None):
+async def server(websocket: "ServerConnection", path: str = "/", ctx: Context = None) -> None:
     client = Client(websocket, ctx)
     ctx.endpoints.append(client)
 
@@ -910,6 +924,10 @@ async def on_client_joined(ctx: Context, client: Client):
                               "If your client supports it, "
                               "you may have additional local commands you can list with /help.",
                       {"type": "Tutorial"})
+    if not any(isinstance(extension, PerMessageDeflate) for extension in client.socket.extensions):
+        ctx.notify_client(client, "Warning: your client does not support compressed websocket connections! "
+                                  "It may stop working in the future. If you are a player, please report this to the "
+                                  "client's developer.")
     ctx.client_connection_timers[client.team, client.slot] = datetime.datetime.now(datetime.timezone.utc)
 
 
@@ -1060,21 +1078,37 @@ def send_items_to(ctx: Context, team: int, target_slot: int, *items: NetworkItem
 
 def register_location_checks(ctx: Context, team: int, slot: int, locations: typing.Iterable[int],
                              count_activity: bool = True):
+    slot_locations = ctx.locations[slot]
     new_locations = set(locations) - ctx.location_checks[team, slot]
-    new_locations.intersection_update(ctx.locations[slot])  # ignore location IDs unknown to this multidata
+    new_locations.intersection_update(slot_locations)  # ignore location IDs unknown to this multidata
     if new_locations:
         if count_activity:
             ctx.client_activity_timers[team, slot] = datetime.datetime.now(datetime.timezone.utc)
+
+        sortable: list[tuple[int, int, int, int]] = []
         for location in new_locations:
-            item_id, target_player, flags = ctx.locations[slot][location]
+            # extract all fields to avoid runtime overhead in LocationStore
+            item_id, target_player, flags = slot_locations[location]
+            # sort/group by receiver and item
+            sortable.append((target_player, item_id, location, flags))
+
+        info_texts: list[dict[str, typing.Any]] = []
+        for target_player, item_id, location, flags in sorted(sortable):
             new_item = NetworkItem(item_id, location, slot, flags)
             send_items_to(ctx, team, target_player, new_item)
 
             ctx.logger.info('(Team #%d) %s sent %s to %s (%s)' % (
                 team + 1, ctx.player_names[(team, slot)], ctx.item_names[ctx.slot_info[target_player].game][item_id],
                 ctx.player_names[(team, target_player)], ctx.location_names[ctx.slot_info[slot].game][location]))
-            info_text = json_format_send_event(new_item, target_player)
-            ctx.broadcast_team(team, [info_text])
+            if len(info_texts) >= 140:
+                # split into chunks that are close to compression window of 64K but not too big on the wire
+                # (roughly 1300-2600 bytes after compression depending on repetitiveness)
+                ctx.broadcast_team(team, info_texts)
+                info_texts.clear()
+            info_texts.append(json_format_send_event(new_item, target_player))
+        ctx.broadcast_team(team, info_texts)
+        del info_texts
+        del sortable
 
         ctx.location_checks[team, slot] |= new_locations
         send_new_items(ctx)
@@ -1101,7 +1135,7 @@ def collect_hints(ctx: Context, team: int, slot: int, item: typing.Union[int, st
     seeked_item_id = item if isinstance(item, int) else ctx.item_names_for_game(ctx.games[slot])[item]
     for finding_player, location_id, item_id, receiving_player, item_flags \
             in ctx.locations.find_item(slots, seeked_item_id):
-        prev_hint = ctx.get_hint(team, slot, location_id)
+        prev_hint = ctx.get_hint(team, finding_player, location_id)
         if prev_hint:
             hints.append(prev_hint)
         else:
@@ -1787,7 +1821,9 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
             ctx.clients[team][slot].append(client)
             client.version = args['version']
             client.tags = args['tags']
-            client.no_locations = 'TextOnly' in client.tags or 'Tracker' in client.tags
+            client.no_locations = "TextOnly" in client.tags or "Tracker" in client.tags
+            # set NoText for old PopTracker clients that predate the tag to save traffic
+            client.no_text = "NoText" in client.tags or ("PopTracker" in client.tags and client.version < (0, 5, 1))
             connected_packet = {
                 "cmd": "Connected",
                 "team": client.team, "slot": client.slot,
@@ -1860,6 +1896,9 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
                 client.tags = args["tags"]
                 if set(old_tags) != set(client.tags):
                     client.no_locations = 'TextOnly' in client.tags or 'Tracker' in client.tags
+                    client.no_text = "NoText" in client.tags or (
+                        "PopTracker" in client.tags and client.version < (0, 5, 1)
+                    )
                     ctx.broadcast_text_all(
                         f"{ctx.get_aliased_name(client.team, client.slot)} (Team #{client.team + 1}) has changed tags "
                         f"from {old_tags} to {client.tags}.",

NetUtils.py

@@ -5,17 +5,18 @@ import enum
 import warnings
 from json import JSONEncoder, JSONDecoder
 
-import websockets
+if typing.TYPE_CHECKING:
+    from websockets import WebSocketServerProtocol as ServerConnection
 
 from Utils import ByValue, Version
 
 
 class HintStatus(ByValue, enum.IntEnum):
-    HINT_FOUND = 0
-    HINT_UNSPECIFIED = 1
+    HINT_UNSPECIFIED = 0
     HINT_NO_PRIORITY = 10
     HINT_AVOID = 20
     HINT_PRIORITY = 30
+    HINT_FOUND = 40
 
 
 class JSONMessagePart(typing.TypedDict, total=False):
@@ -151,7 +152,7 @@ decode = JSONDecoder(object_hook=_object_hook).decode
 
 
 class Endpoint:
-    socket: websockets.WebSocketServerProtocol
+    socket: "ServerConnection"
 
     def __init__(self, socket):
         self.socket = socket

OoTClient.py

@@ -346,7 +346,7 @@ if __name__ == '__main__':
 
     import colorama
 
-    colorama.init()
+    colorama.just_fix_windows_console()
 
     asyncio.run(main())
     colorama.deinit()

Options.py

@@ -1579,10 +1579,11 @@ def dump_player_options(multiworld: MultiWorld) -> None:
             player_output = {
                 "Game": multiworld.game[player],
                 "Name": multiworld.get_player_name(player),
+                "ID": player,
             }
             output.append(player_output)
             for option_key, option in world.options_dataclass.type_hints.items():
-                if issubclass(Removed, option):
+                if option.visibility == Visibility.none:
                     continue
                 display_name = getattr(option, "display_name", option_key)
                 player_output[display_name] = getattr(world.options, option_key).current_option_name
@@ -1591,7 +1592,7 @@ def dump_player_options(multiworld: MultiWorld) -> None:
                     game_option_names.append(display_name)
 
     with open(output_path(f"generate_{multiworld.seed_name}.csv"), mode="w", newline="") as file:
-        fields = ["Game", "Name", *all_option_names]
+        fields = ["ID", "Game", "Name", *all_option_names]
         writer = DictWriter(file, fields)
         writer.writeheader()
         writer.writerows(output)

README.md

@@ -80,6 +80,8 @@ Currently, the following games are supported:
 * Saving Princess
 * Castlevania: Circle of the Moon
 * Inscryption
+* Civilization VI
+* The Legend of Zelda: The Wind Waker
 
 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

SNIClient.py

@@ -735,6 +735,6 @@ async def main() -> None:
 
 
 if __name__ == '__main__':
-    colorama.init()
+    colorama.just_fix_windows_console()
     asyncio.run(main())
     colorama.deinit()

UndertaleClient.py

@@ -500,7 +500,7 @@ def main():
 
     import colorama
 
-    colorama.init()
+    colorama.just_fix_windows_console()
 
     asyncio.run(_main())
     colorama.deinit()

Utils.py

@@ -443,7 +443,8 @@ class RestrictedUnpickler(pickle.Unpickler):
             else:
                 mod = importlib.import_module(module)
             obj = getattr(mod, name)
-            if issubclass(obj, (self.options_module.Option, self.options_module.PlandoConnection)):
+            if issubclass(obj, (self.options_module.Option, self.options_module.PlandoConnection,
+                                self.options_module.PlandoText)):
                 return obj
         # Forbid everything else.
         raise pickle.UnpicklingError(f"global '{module}.{name}' is forbidden")

WargrooveClient.py

@@ -446,6 +446,6 @@ if __name__ == '__main__':
     parser = get_base_parser(description="Wargroove Client, for text interfacing.")
 
     args, rest = parser.parse_known_args()
-    colorama.init()
+    colorama.just_fix_windows_console()
     asyncio.run(main(args))
     colorama.deinit()

WebHostLib/customserver.py

@@ -117,6 +117,7 @@ class WebHostContext(Context):
         self.gamespackage = {"Archipelago": static_gamespackage.get("Archipelago", {})}  # this may be modified by _load
         self.item_name_groups = {"Archipelago": static_item_name_groups.get("Archipelago", {})}
         self.location_name_groups = {"Archipelago": static_location_name_groups.get("Archipelago", {})}
+        missing_checksum = False
 
         for game in list(multidata.get("datapackage", {})):
             game_data = multidata["datapackage"][game]
@@ -132,11 +133,13 @@ class WebHostContext(Context):
                         continue
                     else:
                         self.logger.warning(f"Did not find game_data_package for {game}: {game_data['checksum']}")
+            else:
+                missing_checksum = True  # Game rolled on old AP and will load data package from multidata
             self.gamespackage[game] = static_gamespackage.get(game, {})
             self.item_name_groups[game] = static_item_name_groups.get(game, {})
             self.location_name_groups[game] = static_location_name_groups.get(game, {})
 
-        if not game_data_packages:
+        if not game_data_packages and not missing_checksum:
             # all static -> use the static dicts directly
             self.gamespackage = static_gamespackage
             self.item_name_groups = static_item_name_groups

WebHostLib/requirements.txt

@@ -1,11 +1,11 @@
-flask>=3.0.3
-werkzeug>=3.0.6
+flask>=3.1.0
+werkzeug>=3.1.3
 pony>=0.7.19
-waitress>=3.0.0
+waitress>=3.0.2
 Flask-Caching>=2.3.0
-Flask-Compress>=1.15
-Flask-Limiter>=3.8.0
-bokeh>=3.5.2
-markupsafe>=2.1.5
+Flask-Compress>=1.17
+Flask-Limiter>=3.12
+bokeh>=3.6.3
+markupsafe>=3.0.2
 Markdown>=3.7
 mdx-breakless-lists>=1.0.1

WebHostLib/static/assets/faq/en.md

@@ -22,7 +22,7 @@ players to rely upon each other to complete their game.
 
 While a multiworld game traditionally requires all players to be playing the same game, a multi-game multiworld allows
 players to randomize any of the supported games, and send items between them. This allows players of different
-games to interact with one another in a single multiplayer environment.  Archipelago supports multi-game multiworld.
+games to interact with one another in a single multiplayer environment.  Archipelago supports multi-game multiworlds.
 Here is a list of our [Supported Games](https://archipelago.gg/games).
 
 ## Can I generate a single-player game with Archipelago?

WebHostLib/static/styles/timespinnerTracker.css

@@ -75,6 +75,27 @@
 #inventory-table img.acquired.green{ /*32CD32*/
     filter: hue-rotate(84deg) saturate(10) brightness(0.7);
 }
+#inventory-table img.acquired.hotpink{ /*FF69B4*/
+    filter: sepia(100%) hue-rotate(300deg) saturate(10);
+}
+#inventory-table img.acquired.lightsalmon{ /*FFA07A*/
+    filter: sepia(100%) hue-rotate(347deg) saturate(10);
+}
+#inventory-table img.acquired.crimson{ /*DB143B*/
+    filter: sepia(100%) hue-rotate(318deg) saturate(10) brightness(0.86);
+}
+
+#inventory-table span{
+    color: #B4B4A0;
+    font-size: 40px;
+    max-width: 40px;
+    max-height: 40px;
+    filter: grayscale(100%) contrast(75%) brightness(30%);
+}
+
+#inventory-table span.acquired{
+    filter: none;
+}
 
 #inventory-table div.image-stack{
     display: grid;

WebHostLib/templates/playerOptions/macros.html

@@ -213,7 +213,7 @@
 {% endmacro %}
 
 {% macro RandomizeButton(option_name, option) %}
-    <div class="randomize-button" data-tooltip="Toggle randomization for this option!">
+    <div class="randomize-button" data-tooltip="Pick a random value for this option.">
         <label for="random-{{ option_name }}">
             <input type="checkbox" id="random-{{ option_name }}" name="random-{{ option_name }}" class="randomize-checkbox" data-option-name="{{ option_name }}" {{ "checked" if option.default == "random" }} />
             🎲

WebHostLib/templates/tracker__Timespinner.html

@@ -99,6 +99,52 @@
                 {% endif %}
                 </div>
             </div>
+            {% if 'PrismBreak' in options or 'LockKeyAmadeus' in options or 'GateKeep' in options %}
+            <div class="table-row">
+                {% if 'PrismBreak' in options %}
+                <div class="C1">
+                    <div class="image-stack">
+                        <div class="stack-front">
+                            <div class="stack-top-left">
+                                <img src="{{ icons['Laser Access'] }}" class="hotpink {{ 'acquired' if 'Laser Access A' in acquired_items }}" title="Laser Access A" />
+                            </div>
+                            <div class="stack-top-right">
+                                <img src="{{ icons['Laser Access'] }}" class="lightsalmon {{ 'acquired' if 'Laser Access I' in acquired_items }}" title="Laser Access I" />
+                            </div>
+                            <div class="stack-bottum-left">
+                                <img src="{{ icons['Laser Access'] }}" class="crimson {{ 'acquired' if 'Laser Access M' in acquired_items }}" title="Laser Access M" />
+                            </div>
+                        </div>
+                    </div>
+		</div>
+                {% endif %}
+                {% if 'LockKeyAmadeus' in options %}
+                <div class="C2">
+                    <div class="image-stack">
+                        <div class="stack-front">
+                            <div class="stack-top-left">
+                                <img src="{{ icons['Lab Glasses'] }}" class="{{ 'acquired' if 'Lab Access Genza' in acquired_items }}" title="Lab Access Genza" />
+                            </div>
+                            <div class="stack-top-right">
+                                <img src="{{ icons['Eye Orb'] }}" class="{{ 'acquired' if 'Lab Access Dynamo' in acquired_items }}" title="Lab Access Dynamo" />
+                            </div>
+                            <div class="stack-bottum-left">
+                                <img src="{{ icons['Lab Coat'] }}" class="{{ 'acquired' if 'Lab Access Research' in acquired_items }}" title="Lab Access Research" />
+                            </div>
+                            <div class="stack-bottum-right">
+                                <img src="{{ icons['Demon'] }}" class="{{ 'acquired' if 'Lab Access Experiment' in acquired_items }}" title="Lab Access Experiment" />
+                            </div>
+                        </div>
+                    </div>
+		</div>
+                {% endif %}
+                {% if 'GateKeep' in options %}
+                <div class="C3">
+                    <span class="{{ 'acquired' if 'Drawbridge Key' in acquired_items }}" title="Drawbridge Key">&#10070;</span>
+		</div>
+                {% endif %}
+	    </div>
+            {% endif %}
         </div>
 
         <table id="location-table">

WebHostLib/templates/weightedOptions/weightedOptions.html

@@ -100,7 +100,7 @@
 
                                 {% else %}
                                     <div class="unsupported-option">
-                                        This option is not supported. Please edit your .yaml file manually.
+                                        This option cannot be modified here. Please edit your .yaml file manually.
                                     </div>
 
                                 {% endif %}

WebHostLib/tracker.py

@@ -1071,6 +1071,11 @@ if "Timespinner" in network_data_package["games"]:
             "Plasma Orb":          "https://timespinnerwiki.com/mediawiki/images/4/44/Plasma_Orb.png",
             "Kobo":                "https://timespinnerwiki.com/mediawiki/images/c/c6/Familiar_Kobo.png",
             "Merchant Crow":       "https://timespinnerwiki.com/mediawiki/images/4/4e/Familiar_Crow.png",
+            "Laser Access":        "https://timespinnerwiki.com/mediawiki/images/9/99/Historical_Documents.png",
+            "Lab Glasses":         "https://timespinnerwiki.com/mediawiki/images/4/4a/Lab_Glasses.png",
+            "Eye Orb":             "https://timespinnerwiki.com/mediawiki/images/a/a4/Eye_Orb.png",
+            "Lab Coat":            "https://timespinnerwiki.com/mediawiki/images/5/51/Lab_Coat.png", 
+            "Demon":               "https://timespinnerwiki.com/mediawiki/images/f/f8/Familiar_Demon.png", 
         }
 
         timespinner_location_ids = {
@@ -1118,6 +1123,9 @@ if "Timespinner" in network_data_package["games"]:
             timespinner_location_ids["Ancient Pyramid"] += [
                 1337237, 1337238, 1337239,
                 1337240, 1337241, 1337242, 1337243, 1337244, 1337245]
+        if (slot_data["PyramidStart"]):
+            timespinner_location_ids["Ancient Pyramid"] += [
+                1337233, 1337234, 1337235]
 
         display_data = {}
 

Zelda1Client.py

@@ -386,7 +386,7 @@ if __name__ == '__main__':
     parser.add_argument('diff_file', default="", type=str, nargs="?",
                         help='Path to a Archipelago Binary Patch file')
     args = parser.parse_args()
-    colorama.init()
+    colorama.just_fix_windows_console()
 
     asyncio.run(main(args))
     colorama.deinit()

docs/CODEOWNERS

@@ -45,6 +45,9 @@
 # ChecksFinder
 /worlds/checksfinder/ @SunCatMC
 
+# Civilization VI
+/worlds/civ6/ @hesto2
+
 # Clique
 /worlds/clique/ @ThePhar
 
@@ -211,6 +214,9 @@
 # Wargroove
 /worlds/wargroove/ @FlySniper
 
+# The Wind Waker
+/worlds/tww/ @tanjo3
+
 # The Witness
 /worlds/witness/ @NewSoupVi @blastron
 

docs/entrance randomization.md

@@ -370,19 +370,13 @@ target_group_lookup = bake_target_group_lookup(world, get_target_groups)
 
 #### When to call `randomize_entrances`
 
-The short answer is that you will almost always want to do ER in `pre_fill`. For more information why, continue reading.
+The correct step for this is `World.connect_entrances`.
 
-ER begins by collecting the entire item pool and then uses your access rules to try and prevent some kinds of failures. 
-This means 2 things about when you can call ER:
-1. You must supply your item pool before calling ER, or call ER before setting any rules which require items.
-2. If you have rules dependent on anything other than items (e.g. `Entrance`s or events), you must set your rules
-   and create your events before you call ER if you want to guarantee a correct output.
-
-If the conditions above are met, you could theoretically do ER as early as `create_regions`. However, plando is also 
-a consideration. Since item plando happens between `set_rules` and `pre_fill` and modifies the item pool, doing ER 
-in `pre_fill` is the only way to account for placements made by item plando, otherwise you risk impossible seeds or 
-generation failures. Obviously, if your world implements entrance plando, you will likely want to do that before ER as
-well.
+Currently, you could theoretically do it as early as `World.create_regions` or as late as `pre_fill`.
+However, there are upcoming changes to Item Plando and Generic Entrance Randomizer to make the two features work better
+together.
+These changes necessitate that entrance randomization is done exactly in `World.connect_entrances`.
+It is fine for your Entrances to be connected differently or not at all before this step.
 
 #### Informing your client about randomized entrances
 

docs/network protocol.md

@@ -47,6 +47,9 @@ Packets are simple JSON lists in which any number of ordered network commands ca
 
 An object can contain the "class" key, which will tell the content data type, such as "Version" in the following example.
 
+Websocket connections should support per-message compression. Uncompressed connections are deprecated and may stop
+working in the future.
+
 Example:
 ```javascript
 [{"cmd": "RoomInfo", "version": {"major": 0, "minor": 1, "build": 3, "class": "Version"}, "tags": ["WebHost"], ... }]
@@ -360,11 +363,11 @@ An enumeration containing the possible hint states.
 ```python
 import enum
 class HintStatus(enum.IntEnum):
-    HINT_FOUND = 0        # The location has been collected. Status cannot be changed once found.
-    HINT_UNSPECIFIED = 1  # The receiving player has not specified any status
+    HINT_UNSPECIFIED = 0  # The receiving player has not specified any status
     HINT_NO_PRIORITY = 10 # The receiving player has specified that the item is unneeded
     HINT_AVOID = 20       # The receiving player has specified that the item is detrimental
     HINT_PRIORITY = 30    # The receiving player has specified that the item is needed
+    HINT_FOUND = 40       # The location has been collected. Status cannot be changed once found.
 ```
 - Hints for items with `ItemClassification.trap` default to `HINT_AVOID`.
 - Hints created with `LocationScouts`, `!hint_location`, or similar (hinting a location) default to `HINT_UNSPECIFIED`.
@@ -530,9 +533,9 @@ In JSON this may look like:
     {"item": 3, "location": 3, "player": 3, "flags": 0}
 ]
 ```
-`item` is the item id of the item. Item ids are only supported in the range of [-2<sup>53</sup>, 2<sup>53</sup> - 1], with anything ≤ 0 reserved for Archipelago use.
+`item` is the item id of the item. Item ids are only supported in the range of [-2<sup>53</sup> + 1, 2<sup>53</sup> - 1], with anything ≤ 0 reserved for Archipelago use.
 
-`location` is the location id of the item inside the world. Location ids are only supported in the range of [-2<sup>53</sup>, 2<sup>53</sup> - 1], with anything ≤ 0 reserved for Archipelago use.
+`location` is the location id of the item inside the world. Location ids are only supported in the range of [-2<sup>53</sup> + 1, 2<sup>53</sup> - 1], with anything ≤ 0 reserved for Archipelago use.
 
 `player` is the player slot of the world the item is located in, except when inside an [LocationInfo](#LocationInfo) Packet then it will be the slot of the player to receive the item
 
@@ -745,6 +748,7 @@ Tags are represented as a list of strings, the common client tags follow:
 | HintGame  | Indicates the client is a hint game, made to send hints instead of locations. Special join/leave message,¹ `game` is optional.²      |
 | Tracker   | Indicates the client is a tracker, made to track instead of sending locations. Special join/leave message,¹ `game` is optional.²     |
 | TextOnly  | Indicates the client is a basic client, made to chat instead of sending locations. Special join/leave message,¹ `game` is optional.² |
+| NoText    | Indicates the client does not want to receive text messages, improving performance if not needed.                                    |
 
 ¹: When connecting or disconnecting, the chat message shows e.g. "tracking".\
 ²: Allows `game` to be empty or null in [Connect](#connect). Game and version validation will then be skipped.

docs/tests.md

@@ -73,15 +73,47 @@ When tests are run, this class will create a multiworld with a single player hav
 generic tests, as well as the new custom test. Each test method definition will create its own separate solo multiworld
 that will be cleaned up after. If you don't want to run the generic tests on a base, `run_default_tests` can be
 overridden. For more information on what methods are available to your class, check the
-[WorldTestBase definition](/test/bases.py#L104).
+[WorldTestBase definition](/test/bases.py#L106).
 
 #### Alternatives to WorldTestBase
 
-Unit tests can also be created using [TestBase](/test/bases.py#L14) or
+Unit tests can also be created using [TestBase](/test/bases.py#L16) or
 [unittest.TestCase](https://docs.python.org/3/library/unittest.html#unittest.TestCase) depending on your use case. These
 may be useful for generating a multiworld under very specific constraints without using the generic world setup, or for
 testing portions of your code that can be tested without relying on a multiworld to be created first.
 
+#### Parametrization
+
+When defining a test that needs to cover a range of inputs it is useful to parameterize (to run the same test
+for multiple inputs) the base test. Some important things to consider when attempting to parametrize your test are:
+
+* [Subtests](https://docs.python.org/3/library/unittest.html#distinguishing-test-iterations-using-subtests)
+  can be used to have parametrized assertions that show up similar to individual tests but without the overhead
+  of needing to instantiate multiple tests; however, subtests can not be multithreaded and do not have individual
+  timing data, so they are not suitable for slow tests.
+
+* Archipelago's tests are test-runner-agnostic. That means tests are not allowed to use e.g. `@pytest.mark.parametrize`.
+  Instead, we define our own parametrization helpers in [test.param](/test/param.py).
+
+* Classes inheriting from `WorldTestBase`, including those created by the helpers in `test.param`, will run all
+  base tests by default, make sure the produced tests actually do what you aim for and do not waste a lot of
+  extra CPU time. Consider using `TestBase` or `unittest.TestCase` directly
+  or setting `WorldTestBase.run_default_tests` to False.
+
+#### Performance Considerations
+
+Archipelago is big enough that the runtime of unittests can have an impact on productivity.
+
+Individual tests should take less than a second, so they can be properly multithreaded.
+
+Ideally, thorough tests are directed at actual code/functionality. Do not just create and/or fill a ton of individual
+Multiworlds that spend most of the test time outside what you actually want to test.
+
+Consider generating/validating "random" games as part of your APWorld release workflow rather than having that be part
+of continuous integration, and add minimal reproducers to the "normal" tests for problems that were found.
+You can use [@unittest.skipIf](https://docs.python.org/3/library/unittest.html#unittest.skipIf) with an environment
+variable to keep all the benefits of the test framework while not running the marked tests by default.
+
 ## Running Tests
 
 #### Using Pycharm
@@ -100,3 +132,11 @@ next to the run and debug buttons.
 #### Running Tests without Pycharm
 
 Run `pip install pytest pytest-subtests`, then use your IDE to run tests or run `pytest` from the source folder.
+
+#### Running Tests Multithreaded
+
+pytest can run multiple test runners in parallel with the pytest-xdist extension.
+
+Install with `pip install pytest-xdist`.
+
+Run with `pytest -n12` to spawn 12 process that each run 1/12th of the tests.

docs/world api.md

@@ -222,8 +222,8 @@ could also be progress in a research tree, or even something more abstract like
 
 Each location has a `name` and an `address` (hereafter referred to as an `id`), is placed in a Region, has access rules,
 and has a classification. The name needs to be unique within each game and must not be numeric (must contain least 1
-letter or symbol). The ID needs to be unique across all games, and is best kept in the same range as the item IDs.
-Locations and items can share IDs, so typically a game's locations and items start at the same ID.
+letter or symbol). The ID needs to be unique across all locations within the game. 
+Locations and items can share IDs, and locations can share IDs with other games' locations.
 
 World-specific IDs must be in the range 1 to 2<sup>53</sup>-1; IDs ≤ 0 are global and reserved.
 
@@ -243,7 +243,9 @@ progression. Progression items will be assigned to locations with higher priorit
 and satisfy progression balancing.
 
 The name needs to be unique within each game, meaning if you need to create multiple items with the same name, they
-will all have the same ID. Name must not be numeric (must contain at least 1 letter or symbol).
+will all have the same ID. Name must not be numeric (must contain at least 1 letter or symbol). 
+The ID thus also needs to be unique across all items with different names within the game. 
+Items and locations can share IDs, and items can share IDs with other games' items.
 
 Other classifications include:
 
@@ -289,7 +291,7 @@ like entrance randomization in logic.
 
 Regions have a list called `exits`, containing `Entrance` objects representing transitions to other regions.
 
-There must be one special region (Called "Menu" by default, but configurable using [origin_region_name](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L295-L296)),
+There must be one special region (Called "Menu" by default, but configurable using [origin_region_name](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L298-L299)),
 from which the logic unfolds. AP assumes that a player will always be able to return to this starting region by resetting the game ("Save and quit").
 
 ### Entrances
@@ -329,7 +331,7 @@ Even doing `state.can_reach_location` or `state.can_reach_entrance` is problemat
 You can use `multiworld.register_indirect_condition(region, entrance)` to explicitly tell the generator that, when a given region becomes accessible, it is necessary to re-check a specific entrance.
 You **must** use `multiworld.register_indirect_condition` if you perform this kind of `can_reach` from an entrance access rule, unless you have a **very** good technical understanding of the relevant code and can reason why it will never lead to problems in your case.
 
-Alternatively, you can set [world.explicit_indirect_conditions = False](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L298-L301),
+Alternatively, you can set [world.explicit_indirect_conditions = False](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L301-L304),
 avoiding the need for indirect conditions at the expense of performance.
 
 ### Item Rules
@@ -490,6 +492,9 @@ In addition, the following methods can be implemented and are called in this ord
   after this step. Locations cannot be moved to different regions after this step.
 * `set_rules(self)`
   called to set access and item rules on locations and entrances.
+* `connect_entrances(self)`
+  by the end of this step, all entrances must exist and be connected to their source and target regions.
+  Entrance randomization should be done here.
 * `generate_basic(self)`
   player-specific randomization that does not affect logic can be done here.
 * `pre_fill(self)`, `fill_hook(self)` and `post_fill(self)`
@@ -557,17 +562,13 @@ from .items import is_progression  # this is just a dummy
 
 def create_item(self, item: str) -> MyGameItem:
     # this is called when AP wants to create an item by name (for plando) or when you call it from your own code
-    classification = ItemClassification.progression if is_progression(item) else
-    ItemClassification.filler
-
-
-return MyGameItem(item, classification, self.item_name_to_id[item],
-                  self.player)
+    classification = ItemClassification.progression if is_progression(item) else ItemClassification.filler
+    return MyGameItem(item, classification, self.item_name_to_id[item], self.player)
 
 
 def create_event(self, event: str) -> MyGameItem:
     # while we are at it, we can also add a helper to create events
-    return MyGameItem(event, True, None, self.player)
+    return MyGameItem(event, ItemClassification.progression, None, self.player)
 ```
 
 #### create_items
@@ -835,14 +836,16 @@ def generate_output(self, output_directory: str) -> None:
 
 ### Slot Data
 
-If the game client needs to know information about the generated seed, a preferred method of transferring the data
-is through the slot data. This is filled with the `fill_slot_data` method of your world by returning
-a `dict` with `str` keys that can be serialized with json.
-But, to not waste resources, it should be limited to data that is absolutely necessary. Slot data is sent to your client
-once it has successfully [connected](network%20protocol.md#connected).
+If a client or tracker needs to know information about the generated seed, a preferred method of transferring the data 
+is through the slot data. This is filled with the `fill_slot_data` method of your world by returning a `dict` with 
+`str` keys that can be serialized with json. However, to not waste resources, it should be limited to data that is 
+absolutely necessary. Slot data is sent to your client once it has successfully 
+[connected](network%20protocol.md#connected).
+
 If you need to know information about locations in your world, instead of propagating the slot data, it is preferable
-to use [LocationScouts](network%20protocol.md#locationscouts), since that data already exists on the server. The most
-common usage of slot data is sending option results that the client needs to be aware of.
+to use [LocationScouts](network%20protocol.md#locationscouts), since that data already exists on the server. Adding 
+item/location pairs is unnecessary since the AP server already retains and freely gives that information to clients 
+that request it. The most common usage of slot data is sending option results that the client needs to be aware of.
 
 ```python
 def fill_slot_data(self) -> Dict[str, Any]:

entrance_rando.py

@@ -157,17 +157,16 @@ class ERPlacementState:
     def placed_regions(self) -> set[Region]:
         return self.collection_state.reachable_regions[self.world.player]
 
-    def find_placeable_exits(self, check_validity: bool) -> list[Entrance]:
+    def find_placeable_exits(self, check_validity: bool, usable_exits: list[Entrance]) -> list[Entrance]:
         if check_validity:
             blocked_connections = self.collection_state.blocked_connections[self.world.player]
-            blocked_connections = sorted(blocked_connections, key=lambda x: x.name)
-            placeable_randomized_exits = [connection for connection in blocked_connections
-                                          if not connection.connected_region
-                                          and connection.is_valid_source_transition(self)]
+            placeable_randomized_exits = [ex for ex in usable_exits
+                                          if not ex.connected_region
+                                          and ex in blocked_connections
+                                          and ex.is_valid_source_transition(self)]
         else:
             # this is on a beaten minimal attempt, so any exit anywhere is fair game
-            placeable_randomized_exits = [ex for region in self.world.multiworld.get_regions(self.world.player)
-                                          for ex in region.exits if not ex.connected_region]
+            placeable_randomized_exits = [ex for ex in usable_exits if not ex.connected_region]
         self.world.random.shuffle(placeable_randomized_exits)
         return placeable_randomized_exits
 
@@ -181,7 +180,8 @@ class ERPlacementState:
         self.placements.append(source_exit)
         self.pairings.append((source_exit.name, target_entrance.name))
 
-    def test_speculative_connection(self, source_exit: Entrance, target_entrance: Entrance) -> bool:
+    def test_speculative_connection(self, source_exit: Entrance, target_entrance: Entrance,
+                                    usable_exits: set[Entrance]) -> bool:
         copied_state = self.collection_state.copy()
         # simulated connection. A real connection is unsafe because the region graph is shallow-copied and would
         # propagate back to the real multiworld.
@@ -198,6 +198,9 @@ class ERPlacementState:
             # ignore the source exit, and, if coupled, the reverse exit. They're not actually new
             if _exit.name == source_exit.name or (self.coupled and _exit.name == target_entrance.name):
                 continue
+            # make sure we are only paying attention to usable exits
+            if _exit not in usable_exits:
+                continue
             # technically this should be is_valid_source_transition, but that may rely on side effects from
             # on_connect, which have not happened here (because we didn't do a real connection, and if we did, we would
             # not want them to persist). can_reach is a close enough approximation most of the time.
@@ -262,14 +265,19 @@ def bake_target_group_lookup(world: World, get_target_groups: Callable[[int], li
     return { group: get_target_groups(group) for group in unique_groups }
 
 
-def disconnect_entrance_for_randomization(entrance: Entrance, target_group: int | None = None) -> None:
+def disconnect_entrance_for_randomization(entrance: Entrance, target_group: int | None = None,
+                                          one_way_target_name: str | None = None) -> None:
     """
     Given an entrance in a "vanilla" region graph, splits that entrance to prepare it for randomization
-    in randomize_entrances. This should be done after setting the type and group of the entrance.
+    in randomize_entrances. This should be done after setting the type and group of the entrance. Because it attempts
+    to meet strict entrance naming requirements for coupled mode, this function may produce unintuitive results when
+    called only on a single entrance; it produces eventually-correct outputs only after calling it on all entrances.
 
     :param entrance: The entrance which will be disconnected in preparation for randomization.
     :param target_group: The group to assign to the created ER target. If not specified, the group from
                          the original entrance will be copied.
+    :param one_way_target_name: The name of the created ER target if `entrance` is one-way. This argument
+                                is required for one-way entrances and is ignored otherwise.
     """
     child_region = entrance.connected_region
     parent_region = entrance.parent_region
@@ -284,8 +292,11 @@ def disconnect_entrance_for_randomization(entrance: Entrance, target_group: int
         # targets in the child region will be created when the other direction edge is disconnected
         target = parent_region.create_er_target(entrance.name)
     else:
-        # for 1-ways, the child region needs a target and coupling/naming is not a concern
-        target = child_region.create_er_target(child_region.name)
+        # for 1-ways, the child region needs a target. naming is not a concern for coupling so we
+        # allow it to be user provided (and require it, to prevent an unhelpful assumed name in pairings)
+        if not one_way_target_name:
+            raise ValueError("Cannot disconnect a one-way entrance without a target name specified")
+        target = child_region.create_er_target(one_way_target_name)
     target.randomization_type = entrance.randomization_type
     target.randomization_group = target_group or entrance.randomization_group
 
@@ -326,6 +337,24 @@ def randomize_entrances(
     # similar to fill, skip validity checks on entrances if the game is beatable on minimal accessibility
     perform_validity_check = True
 
+    if not er_targets:
+        er_targets = sorted([entrance for region in world.multiworld.get_regions(world.player)
+                             for entrance in region.entrances if not entrance.parent_region], key=lambda x: x.name)
+    if not exits:
+        exits = sorted([ex for region in world.multiworld.get_regions(world.player)
+                        for ex in region.exits if not ex.connected_region], key=lambda x: x.name)
+    if len(er_targets) != len(exits):
+        raise EntranceRandomizationError(f"Unable to randomize entrances due to a mismatched count of "
+                                         f"entrances ({len(er_targets)}) and exits ({len(exits)}.")
+
+    # used when membership checks are needed on the exit list, e.g. speculative sweep
+    exits_set = set(exits)
+    for entrance in er_targets:
+        entrance_lookup.add(entrance)
+
+    # place the menu region and connected start region(s)
+    er_state.collection_state.update_reachable_regions(world.player)
+
     def do_placement(source_exit: Entrance, target_entrance: Entrance) -> None:
         placed_exits, removed_entrances = er_state.connect(source_exit, target_entrance)
         # remove the placed targets from consideration
@@ -337,9 +366,37 @@ def randomize_entrances(
         if on_connect:
             on_connect(er_state, placed_exits)
 
+    def needs_speculative_sweep(dead_end: bool, require_new_exits: bool, placeable_exits: list[Entrance]) -> bool:
+        # speculative sweep is expensive. We currently only do it as a last resort, if we might cap off the graph
+        # entirely
+        if len(placeable_exits) > 1:
+            return False
+
+        # in certain stages of randomization we either expect or don't care if the search space shrinks.
+        # we should never speculative sweep here.
+        if dead_end or not require_new_exits or not perform_validity_check:
+            return False
+
+        # edge case - if all dead ends have pre-placed progression or indirect connections, they are pulled forward
+        # into the non dead end stage. In this case, and only this case, it's possible that the last connection may
+        # actually be placeable in stage 1. We need to skip speculative sweep in this case because we expect the graph
+        # to get capped off.
+
+        # check to see if we are proposing the last placement
+        if not coupled:
+            # in uncoupled, this check is easy as there will only be one target.
+            is_last_placement = len(entrance_lookup) == 1
+        else:
+            # a bit harder, there may be 1 or 2 targets depending on if the exit to place is one way or two way.
+            # if it is two way, we can safely assume that one of the targets is the logical pair of the exit.
+            desired_target_count = 2 if placeable_exits[0].randomization_type == EntranceType.TWO_WAY else 1
+            is_last_placement = len(entrance_lookup) == desired_target_count
+        # if it's not the last placement, we need a sweep
+        return not is_last_placement
+
     def find_pairing(dead_end: bool, require_new_exits: bool) -> bool:
         nonlocal perform_validity_check
-        placeable_exits = er_state.find_placeable_exits(perform_validity_check)
+        placeable_exits = er_state.find_placeable_exits(perform_validity_check, exits)
         for source_exit in placeable_exits:
             target_groups = target_group_lookup[source_exit.randomization_group]
             for target_entrance in entrance_lookup.get_targets(target_groups, dead_end, preserve_group_order):
@@ -350,12 +407,10 @@ def randomize_entrances(
                 # very last exit and check whatever exits we open up are functionally accessible.
                 # this requirement can be ignored on a beaten minimal, islands are no issue there.
                 exit_requirement_satisfied = (not perform_validity_check or not require_new_exits
-                                                or target_entrance.connected_region not in er_state.placed_regions)
-                needs_speculative_sweep = (not dead_end and require_new_exits and perform_validity_check
-                                           and len(placeable_exits) == 1)
+                                              or target_entrance.connected_region not in er_state.placed_regions)
                 if exit_requirement_satisfied and source_exit.can_connect_to(target_entrance, dead_end, er_state):
-                    if (needs_speculative_sweep
-                            and not er_state.test_speculative_connection(source_exit, target_entrance)):
+                    if (needs_speculative_sweep(dead_end, require_new_exits, placeable_exits)
+                            and not er_state.test_speculative_connection(source_exit, target_entrance, exits_set)):
                         continue
                     do_placement(source_exit, target_entrance)
                     return True
@@ -378,13 +433,14 @@ def randomize_entrances(
                     and world.multiworld.has_beaten_game(er_state.collection_state, world.player):
                 # ensure that we have enough locations to place our progression
                 accessible_location_count = 0
-                prog_item_count = sum(er_state.collection_state.prog_items[world.player].values())
+                prog_item_count = len([item for item in world.multiworld.itempool if item.advancement and item.player == world.player])
                 # short-circuit location checking in this case
                 if prog_item_count == 0:
                     return True
                 for region in er_state.placed_regions:
                     for loc in region.locations:
-                        if loc.can_reach(er_state.collection_state):
+                        if not loc.item and loc.can_reach(er_state.collection_state):
+                            # don't count locations with preplaced items
                             accessible_location_count += 1
                             if accessible_location_count >= prog_item_count:
                                 perform_validity_check = False
@@ -406,21 +462,6 @@ def randomize_entrances(
                 f"All unplaced entrances: {unplaced_entrances}\n"
                 f"All unplaced exits: {unplaced_exits}")
 
-    if not er_targets:
-        er_targets = sorted([entrance for region in world.multiworld.get_regions(world.player)
-                             for entrance in region.entrances if not entrance.parent_region], key=lambda x: x.name)
-    if not exits:
-        exits = sorted([ex for region in world.multiworld.get_regions(world.player)
-                        for ex in region.exits if not ex.connected_region], key=lambda x: x.name)
-    if len(er_targets) != len(exits):
-        raise EntranceRandomizationError(f"Unable to randomize entrances due to a mismatched count of "
-                                         f"entrances ({len(er_targets)}) and exits ({len(exits)}.")
-    for entrance in er_targets:
-        entrance_lookup.add(entrance)
-
-    # place the menu region and connected start region(s)
-    er_state.collection_state.update_reachable_regions(world.player)
-
     # stage 1 - try to place all the non-dead-end entrances
     while entrance_lookup.others:
         if not find_pairing(dead_end=False, require_new_exits=True):

inno_setup.iss

@@ -221,6 +221,11 @@ Root: HKCR; Subkey: "{#MyAppName}ygo06patch";                     ValueData: "Ar
 Root: HKCR; Subkey: "{#MyAppName}ygo06patch\DefaultIcon";         ValueData: "{app}\ArchipelagoBizHawkClient.exe,0";                           ValueType: string;  ValueName: "";
 Root: HKCR; Subkey: "{#MyAppName}ygo06patch\shell\open\command";  ValueData: """{app}\ArchipelagoBizHawkClient.exe"" ""%1""";                  ValueType: string;  ValueName: "";
 
+Root: HKCR; Subkey: ".apcivvi";                                   ValueData: "{#MyAppName}apcivvipatch";        Flags: uninsdeletevalue; ValueType: string;  ValueName: "";
+Root: HKCR; Subkey: "{#MyAppName}apcivvipatch";                     ValueData: "Archipelago Civilization 6 Patch"; Flags: uninsdeletekey;   ValueType: string;  ValueName: "";
+Root: HKCR; Subkey: "{#MyAppName}apcivvipatch\DefaultIcon";         ValueData: "{app}\ArchipelagoLauncher.exe,0";                           ValueType: string;  ValueName: "";
+Root: HKCR; Subkey: "{#MyAppName}apcivvipatch\shell\open\command";  ValueData: """{app}\ArchipelagoLauncher.exe"" ""%1""";                  ValueType: string;  ValueName: "";
+
 Root: HKCR; Subkey: ".archipelago";                              ValueData: "{#MyAppName}multidata";        Flags: uninsdeletevalue; ValueType: string;  ValueName: "";
 Root: HKCR; Subkey: "{#MyAppName}multidata";                     ValueData: "Archipelago Server Data";      Flags: uninsdeletekey;   ValueType: string;  ValueName: "";
 Root: HKCR; Subkey: "{#MyAppName}multidata\DefaultIcon";         ValueData: "{app}\ArchipelagoServer.exe,0";                         ValueType: string;  ValueName: "";

kvui.py

@@ -26,6 +26,10 @@ import Utils
 if Utils.is_frozen():
     os.environ["KIVY_DATA_DIR"] = Utils.local_path("data")
 
+import platformdirs
+os.environ["KIVY_HOME"] = os.path.join(platformdirs.user_config_dir("Archipelago", False), "kivy")
+os.makedirs(os.environ["KIVY_HOME"], exist_ok=True)
+
 from kivy.config import Config
 
 Config.set("input", "mouse", "mouse,disable_multitouch")
@@ -440,8 +444,11 @@ class HintLabel(RecycleDataViewBehavior, BoxLayout):
                 if child.collide_point(*touch.pos):
                     key = child.sort_key
                     if key == "status":
-                        parent.hint_sorter = lambda element: element["status"]["hint"]["status"]
-                    else: parent.hint_sorter = lambda element: remove_between_brackets.sub("", element[key]["text"]).lower()
+                        parent.hint_sorter = lambda element: status_sort_weights[element["status"]["hint"]["status"]]
+                    else:
+                        parent.hint_sorter = lambda element: (
+                            remove_between_brackets.sub("", element[key]["text"]).lower()
+                        )
                     if key == parent.sort_key:
                         # second click reverses order
                         parent.reversed = not parent.reversed
@@ -810,6 +817,12 @@ class HintLayout(BoxLayout):
         boxlayout.add_widget(AutocompleteHintInput())
         self.add_widget(boxlayout)
 
+    def fix_heights(self):
+        for child in self.children:
+            fix_func = getattr(child, "fix_heights", None)
+            if fix_func:
+                fix_func()
+
         
 status_names: typing.Dict[HintStatus, str] = {
     HintStatus.HINT_FOUND: "Found",
@@ -825,7 +838,13 @@ status_colors: typing.Dict[HintStatus, str] = {
     HintStatus.HINT_AVOID: "salmon",
     HintStatus.HINT_PRIORITY: "plum",
 }
-
+status_sort_weights: dict[HintStatus, int] = {
+    HintStatus.HINT_FOUND: 0,
+    HintStatus.HINT_UNSPECIFIED: 1,
+    HintStatus.HINT_NO_PRIORITY: 2,
+    HintStatus.HINT_AVOID: 3,
+    HintStatus.HINT_PRIORITY: 4,
+}
 
 
 class HintLog(RecycleView):

requirements.txt

@@ -1,14 +1,14 @@
 colorama>=0.4.6
 websockets>=13.0.1,<14
 PyYAML>=6.0.2
-jellyfish>=1.1.0
-jinja2>=3.1.4
+jellyfish>=1.1.3
+jinja2>=3.1.6
 schema>=0.7.7
-kivy>=2.3.0
-bsdiff4>=1.2.4
-platformdirs>=4.2.2
-certifi>=2024.12.14
-cython>=3.0.11
-cymem>=2.0.8
-orjson>=3.10.7
+kivy>=2.3.1
+bsdiff4>=1.2.6
+platformdirs>=4.3.6
+certifi>=2025.1.31
+cython>=3.0.12
+cymem>=2.0.11
+orjson>=3.10.15
 typing_extensions>=4.12.2

settings.py

@@ -109,7 +109,7 @@ class Group:
     def get_type_hints(cls) -> Dict[str, Any]:
         """Returns resolved type hints for the class"""
         if cls._type_cache is None:
-            if not isinstance(next(iter(cls.__annotations__.values())), str):
+            if not cls.__annotations__ or not isinstance(next(iter(cls.__annotations__.values())), str):
                 # non-str: assume already resolved
                 cls._type_cache = cls.__annotations__
             else:
@@ -270,15 +270,20 @@ class Group:
             # fetch class to avoid going through getattr
             cls = self.__class__
             type_hints = cls.get_type_hints()
+            entries = [e for e in self]
+            if not entries:
+                # write empty dict for empty Group with no instance values
+                cls._dump_value({}, f, indent="  " * level)
             # validate group
             for name in cls.__annotations__.keys():
                 assert hasattr(cls, name), f"{cls}.{name} is missing a default value"
             # dump ordered members
-            for name in self:
+            for name in entries:
                 attr = cast(object, getattr(self, name))
                 attr_cls = type_hints[name] if name in type_hints else attr.__class__
                 attr_cls_origin = typing.get_origin(attr_cls)
-                while attr_cls_origin is Union:  # resolve to first type for doc string
+                # resolve to first type for doc string
+                while attr_cls_origin is Union or attr_cls_origin is types.UnionType:
                     attr_cls = typing.get_args(attr_cls)[0]
                     attr_cls_origin = typing.get_origin(attr_cls)
                 if attr_cls.__doc__ and attr_cls.__module__ != "builtins":
@@ -787,7 +792,17 @@ class Settings(Group):
         if location:
             from Utils import parse_yaml
             with open(location, encoding="utf-8-sig") as f:
-                options = parse_yaml(f.read())
+                from yaml.error import MarkedYAMLError
+                try:
+                    options = parse_yaml(f.read())
+                except MarkedYAMLError as ex:
+                    if ex.problem_mark:
+                        f.seek(0)
+                        lines = f.readlines()
+                        problem_line = lines[ex.problem_mark.line]
+                        error_line = " " * ex.problem_mark.column + "^"
+                        raise Exception(f"{ex.context} {ex.problem}\n{problem_line}{error_line}")
+                    raise ex
                 # TODO: detect if upgrade is required
                 # TODO: once we have a cache for _world_settings_name_cache, detect if any game section is missing
                 self.update(options or {})

setup.py

@@ -19,7 +19,7 @@ from typing import Dict, Iterable, List, Optional, Sequence, Set, Tuple, Union
 
 
 # This is a bit jank. We need cx-Freeze to be able to run anything from this script, so install it
-requirement = 'cx-Freeze==7.2.0'
+requirement = 'cx-Freeze==8.0.0'
 try:
     import pkg_resources
     try:

test/benchmark/locations.py

@@ -18,7 +18,15 @@ def run_locations_benchmark():
 
     class BenchmarkRunner:
         gen_steps: typing.Tuple[str, ...] = (
-            "generate_early", "create_regions", "create_items", "set_rules", "generate_basic", "pre_fill")
+            "generate_early",
+            "create_regions",
+            "create_items",
+            "set_rules",
+            "connect_entrances",
+            "generate_basic",
+            "pre_fill",
+        )
+
         rule_iterations: int = 100_000
 
         if sys.version_info >= (3, 9):

test/cpp/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.16)
 project(ap-cpp-tests)
 
 enable_testing()
@@ -7,8 +7,8 @@ find_package(GTest REQUIRED)
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
     add_definitions("/source-charset:utf-8")
-    set(CMAKE_CXX_FLAGS_DEBUG "/MTd")
-    set(CMAKE_CXX_FLAGS_RELEASE "/MT")
+    # set(CMAKE_CXX_FLAGS_DEBUG "/MDd") # this is the default
+    # set(CMAKE_CXX_FLAGS_RELEASE "/MD") # this is the default
 elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     # enable static analysis for gcc
     add_compile_options(-fanalyzer -Werror)

test/general/__init__.py

@@ -5,7 +5,15 @@ from BaseClasses import CollectionState, Item, ItemClassification, Location, Mul
 from worlds import network_data_package
 from worlds.AutoWorld import World, call_all
 
-gen_steps = ("generate_early", "create_regions", "create_items", "set_rules", "generate_basic", "pre_fill")
+gen_steps = (
+    "generate_early",
+    "create_regions",
+    "create_items",
+    "set_rules",
+    "connect_entrances",
+    "generate_basic",
+    "pre_fill",
+)
 
 
 def setup_solo_multiworld(

test/general/test_entrance_rando.py

@@ -148,7 +148,7 @@ class TestDisconnectForRandomization(unittest.TestCase):
         e.randomization_group = 1
         e.connect(r2)
 
-        disconnect_entrance_for_randomization(e)
+        disconnect_entrance_for_randomization(e, one_way_target_name="foo")
 
         self.assertIsNone(e.connected_region)
         self.assertEqual([], r1.entrances)
@@ -158,10 +158,22 @@ class TestDisconnectForRandomization(unittest.TestCase):
 
         self.assertEqual(1, len(r2.entrances))
         self.assertIsNone(r2.entrances[0].parent_region)
-        self.assertEqual("r2", r2.entrances[0].name)
+        self.assertEqual("foo", r2.entrances[0].name)
         self.assertEqual(EntranceType.ONE_WAY, r2.entrances[0].randomization_type)
         self.assertEqual(1, r2.entrances[0].randomization_group)
 
+    def test_disconnect_default_1way_no_vanilla_target_raises(self):
+        multiworld = generate_test_multiworld()
+        r1 = Region("r1", 1, multiworld)
+        r2 = Region("r2", 1, multiworld)
+        e = r1.create_exit("e")
+        e.randomization_type = EntranceType.ONE_WAY
+        e.randomization_group = 1
+        e.connect(r2)
+
+        with self.assertRaises(ValueError):
+            disconnect_entrance_for_randomization(e)
+
     def test_disconnect_uses_alternate_group(self):
         multiworld = generate_test_multiworld()
         r1 = Region("r1", 1, multiworld)
@@ -171,7 +183,7 @@ class TestDisconnectForRandomization(unittest.TestCase):
         e.randomization_group = 1
         e.connect(r2)
 
-        disconnect_entrance_for_randomization(e, 2)
+        disconnect_entrance_for_randomization(e, 2, "foo")
 
         self.assertIsNone(e.connected_region)
         self.assertEqual([], r1.entrances)
@@ -181,7 +193,7 @@ class TestDisconnectForRandomization(unittest.TestCase):
 
         self.assertEqual(1, len(r2.entrances))
         self.assertIsNone(r2.entrances[0].parent_region)
-        self.assertEqual("r2", r2.entrances[0].name)
+        self.assertEqual("foo", r2.entrances[0].name)
         self.assertEqual(EntranceType.ONE_WAY, r2.entrances[0].randomization_type)
         self.assertEqual(2, r2.entrances[0].randomization_group)
 
@@ -218,7 +230,7 @@ class TestRandomizeEntrances(unittest.TestCase):
         self.assertEqual(80, len(result.pairings))
         self.assertEqual(80, len(result.placements))
 
-    def test_coupling(self):
+    def test_coupled(self):
         """tests that in coupled mode, all 2 way transitions have an inverse"""
         multiworld = generate_test_multiworld()
         generate_disconnected_region_grid(multiworld, 5)
@@ -236,6 +248,36 @@ class TestRandomizeEntrances(unittest.TestCase):
         # if we didn't visit every placement the verification on_connect doesn't really mean much
         self.assertEqual(len(result.placements), seen_placement_count)
 
+    def test_uncoupled_succeeds_stage1_indirect_condition(self):
+        multiworld = generate_test_multiworld()
+        menu = multiworld.get_region("Menu", 1)
+        generate_entrance_pair(menu, "_right", ERTestGroups.RIGHT)
+        end = Region("End", 1, multiworld)
+        multiworld.regions.append(end)
+        generate_entrance_pair(end, "_left", ERTestGroups.LEFT)
+        multiworld.register_indirect_condition(end, None)
+
+        result = randomize_entrances(multiworld.worlds[1], False, directionally_matched_group_lookup)
+        self.assertSetEqual({
+            ("Menu_right", "End_left"),
+            ("End_left", "Menu_right")
+        }, set(result.pairings))
+
+    def test_coupled_succeeds_stage1_indirect_condition(self):
+        multiworld = generate_test_multiworld()
+        menu = multiworld.get_region("Menu", 1)
+        generate_entrance_pair(menu, "_right", ERTestGroups.RIGHT)
+        end = Region("End", 1, multiworld)
+        multiworld.regions.append(end)
+        generate_entrance_pair(end, "_left", ERTestGroups.LEFT)
+        multiworld.register_indirect_condition(end, None)
+
+        result = randomize_entrances(multiworld.worlds[1], True, directionally_matched_group_lookup)
+        self.assertSetEqual({
+            ("Menu_right", "End_left"),
+            ("End_left", "Menu_right")
+        }, set(result.pairings))
+
     def test_uncoupled(self):
         """tests that in uncoupled mode, no transitions have an (intentional) inverse"""
         multiworld = generate_test_multiworld()
@@ -311,6 +353,37 @@ class TestRandomizeEntrances(unittest.TestCase):
         self.assertEqual([], [exit_ for region in multiworld.get_regions()
                               for exit_ in region.exits if not exit_.connected_region])
 
+    def test_minimal_entrance_rando_with_collect_override(self):
+        """
+        tests that entrance randomization can complete with minimal accessibility and unreachable exits
+        when the world defines a collect override that add extra values to prog_items
+        """
+        multiworld = generate_test_multiworld()
+        multiworld.worlds[1].options.accessibility = Accessibility.from_any(Accessibility.option_minimal)
+        multiworld.completion_condition[1] = lambda state: state.can_reach("region24", player=1)
+        generate_disconnected_region_grid(multiworld, 5, 1)
+        prog_items = generate_items(10, 1, True)
+        multiworld.itempool += prog_items
+        filler_items = generate_items(15, 1, False)
+        multiworld.itempool += filler_items
+        e = multiworld.get_entrance("region1_right", 1)
+        set_rule(e, lambda state: False)
+
+        old_collect = multiworld.worlds[1].collect
+
+        def new_collect(state, item):
+            old_collect(state, item)
+            state.prog_items[item.player]["counter"] += 300
+
+        multiworld.worlds[1].collect = new_collect
+
+        randomize_entrances(multiworld.worlds[1], False, directionally_matched_group_lookup)
+
+        self.assertEqual([], [entrance for region in multiworld.get_regions()
+                              for entrance in region.entrances if not entrance.parent_region])
+        self.assertEqual([], [exit_ for region in multiworld.get_regions()
+                              for exit_ in region.exits if not exit_.connected_region])
+
     def test_restrictive_region_requirement_does_not_fail(self):
         multiworld = generate_test_multiworld()
         generate_disconnected_region_grid(multiworld, 2, 1)

test/general/test_entrances.py

@@ -0,0 +1,63 @@
+import unittest
+from worlds.AutoWorld import AutoWorldRegister, call_all, World
+from . import setup_solo_multiworld
+
+
+class TestBase(unittest.TestCase):
+    def test_entrance_connection_steps(self):
+        """Tests that Entrances are connected and not changed after connect_entrances."""
+        def get_entrance_name_to_source_and_target_dict(world: World):
+            return [
+                (entrance.name, entrance.parent_region, entrance.connected_region)
+                for entrance in world.get_entrances()
+            ]
+
+        gen_steps = ("generate_early", "create_regions", "create_items", "set_rules", "connect_entrances")
+        additional_steps = ("generate_basic", "pre_fill")
+
+        for game_name, world_type in AutoWorldRegister.world_types.items():
+            with self.subTest("Game", game_name=game_name):
+                multiworld = setup_solo_multiworld(world_type, gen_steps)
+
+                original_entrances = get_entrance_name_to_source_and_target_dict(multiworld.worlds[1])
+
+                self.assertTrue(
+                    all(entrance[1] is not None and entrance[2] is not None for entrance in original_entrances),
+                    f"{game_name} had unconnected entrances after connect_entrances"
+                )
+
+                for step in additional_steps:
+                    with self.subTest("Step", step=step):
+                        call_all(multiworld, step)
+                        step_entrances = get_entrance_name_to_source_and_target_dict(multiworld.worlds[1])
+
+                        self.assertEqual(
+                            original_entrances, step_entrances, f"{game_name} modified entrances during {step}"
+                        )
+
+    def test_all_state_before_connect_entrances(self):
+        """Before connect_entrances, Entrance objects may be unconnected.
+        Thus, we test that get_all_state is performed with allow_partial_entrances if used before or during
+        connect_entrances."""
+
+        gen_steps = ("generate_early", "create_regions", "create_items", "set_rules", "connect_entrances")
+
+        for game_name, world_type in AutoWorldRegister.world_types.items():
+            with self.subTest("Game", game_name=game_name):
+                multiworld = setup_solo_multiworld(world_type, ())
+
+                original_get_all_state = multiworld.get_all_state
+
+                def patched_get_all_state(use_cache: bool, allow_partial_entrances: bool = False):
+                    self.assertTrue(allow_partial_entrances, (
+                        "Before the connect_entrances step finishes, other worlds might still have partial entrances. "
+                        "As such, any call to get_all_state must use allow_partial_entrances = True."
+                    ))
+
+                    return original_get_all_state(use_cache, allow_partial_entrances)
+
+                multiworld.get_all_state = patched_get_all_state
+
+                for step in gen_steps:
+                    with self.subTest("Step", step=step):
+                        call_all(multiworld, step)

test/general/test_items.py

@@ -1,5 +1,6 @@
 import unittest
 
+from BaseClasses import CollectionState
 from worlds.AutoWorld import AutoWorldRegister, call_all
 from . import setup_solo_multiworld
 
@@ -8,12 +9,31 @@ class TestBase(unittest.TestCase):
     def test_create_item(self):
         """Test that a world can successfully create all items in its datapackage"""
         for game_name, world_type in AutoWorldRegister.world_types.items():
-            proxy_world = setup_solo_multiworld(world_type, ()).worlds[1]
+            multiworld = setup_solo_multiworld(world_type, steps=("generate_early", "create_regions", "create_items"))
+            proxy_world = multiworld.worlds[1]
             for item_name in world_type.item_name_to_id:
+                test_state = CollectionState(multiworld)
                 with self.subTest("Create Item", item_name=item_name, game_name=game_name):
                     item = proxy_world.create_item(item_name)
+
+                with self.subTest("Item Name", item_name=item_name, game_name=game_name):
                     self.assertEqual(item.name, item_name)
 
+                if item.advancement:
+                    with self.subTest("Item State Collect", item_name=item_name, game_name=game_name):
+                        test_state.collect(item, True)
+
+                    with self.subTest("Item State Remove", item_name=item_name, game_name=game_name):
+                        test_state.remove(item)
+
+                        self.assertEqual(test_state.prog_items, multiworld.state.prog_items,
+                                         "Item Collect -> Remove should restore empty state.")
+                else:
+                    with self.subTest("Item State Collect No Change", item_name=item_name, game_name=game_name):
+                        # Non-Advancement should not modify state.
+                        test_state.collect(item)
+                        self.assertEqual(test_state.prog_items, multiworld.state.prog_items)
+
     def test_item_name_group_has_valid_item(self):
         """Test that all item name groups contain valid items. """
         # This cannot test for Event names that you may have declared for logic, only sendable Items.
@@ -67,7 +87,7 @@ class TestBase(unittest.TestCase):
     def test_itempool_not_modified(self):
         """Test that worlds don't modify the itempool after `create_items`"""
         gen_steps = ("generate_early", "create_regions", "create_items")
-        additional_steps = ("set_rules", "generate_basic", "pre_fill")
+        additional_steps = ("set_rules", "connect_entrances", "generate_basic", "pre_fill")
         excluded_games = ("Links Awakening DX", "Ocarina of Time", "SMZ3")
         worlds_to_test = {game: world
                           for game, world in AutoWorldRegister.world_types.items() if game not in excluded_games}
@@ -84,7 +104,7 @@ class TestBase(unittest.TestCase):
     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")
+        additional_steps = ("set_rules", "connect_entrances", "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):

test/general/test_locations.py

@@ -45,6 +45,12 @@ class TestBase(unittest.TestCase):
                 self.assertEqual(location_count, len(multiworld.get_locations()),
                                  f"{game_name} modified locations count during rule creation")
 
+                call_all(multiworld, "connect_entrances")
+                self.assertEqual(region_count, len(multiworld.get_regions()),
+                                 f"{game_name} modified region count during rule creation")
+                self.assertEqual(location_count, len(multiworld.get_locations()),
+                                 f"{game_name} modified locations count during rule creation")
+
                 call_all(multiworld, "generate_basic")
                 self.assertEqual(region_count, len(multiworld.get_regions()),
                                  f"{game_name} modified region count during generate_basic")

test/general/test_memory.py

@@ -1,5 +1,6 @@
 import unittest
 
+from BaseClasses import MultiWorld
 from worlds.AutoWorld import AutoWorldRegister
 from . import setup_solo_multiworld
 
@@ -9,8 +10,12 @@ class TestWorldMemory(unittest.TestCase):
         """Tests that worlds don't leak references to MultiWorld or themselves with default options."""
         import gc
         import weakref
+        refs: dict[str, weakref.ReferenceType[MultiWorld]] = {}
         for game_name, world_type in AutoWorldRegister.world_types.items():
-            with self.subTest("Game", game_name=game_name):
+            with self.subTest("Game creation", game_name=game_name):
                 weak = weakref.ref(setup_solo_multiworld(world_type))
-                gc.collect()
+                refs[game_name] = weak
+        gc.collect()
+        for game_name, weak in refs.items():
+            with self.subTest("Game cleanup", game_name=game_name):
                 self.assertFalse(weak(), "World leaked a reference")

test/general/test_packages.py

@@ -0,0 +1,14 @@
+import unittest
+import os
+
+
+class TestPackages(unittest.TestCase):
+    def test_packages_have_init(self):
+        """Test that all world folders containing .py files also have a __init__.py file,
+        to indicate full package rather than namespace package."""
+        import Utils
+
+        worlds_path = Utils.local_path("worlds")
+        for dirpath, dirnames, filenames in os.walk(worlds_path):
+            with self.subTest(directory=dirpath):
+                self.assertEqual("__init__.py" in filenames, any(file.endswith(".py") for file in filenames))

test/general/test_patches.py

@@ -0,0 +1,11 @@
+import unittest
+from worlds.AutoWorld import AutoWorldRegister
+from worlds.Files import AutoPatchRegister
+
+
+class TestPatches(unittest.TestCase):
+    def test_patch_name_matches_game(self) -> None:
+        for game_name in AutoPatchRegister.patch_types:
+            with self.subTest(game=game_name):
+                self.assertIn(game_name, AutoWorldRegister.world_types.keys(),
+                              f"Patch '{game_name}' does not match the name of any world.")

test/general/test_reachability.py

@@ -2,11 +2,11 @@ import unittest
 
 from BaseClasses import CollectionState
 from worlds.AutoWorld import AutoWorldRegister
-from . import setup_solo_multiworld
+from . import setup_solo_multiworld, gen_steps
 
 
 class TestBase(unittest.TestCase):
-    gen_steps = ["generate_early", "create_regions", "create_items", "set_rules", "generate_basic", "pre_fill"]
+    gen_steps = gen_steps
 
     default_settings_unreachable_regions = {
         "A Link to the Past": {

test/general/test_requirements.py

@@ -0,0 +1,19 @@
+import unittest
+import os
+
+
+class TestBase(unittest.TestCase):
+    def test_requirements_file_ends_on_newline(self):
+        """Test that all requirements files end on a newline"""
+        import Utils
+        requirements_files = [Utils.local_path("requirements.txt"),
+                              Utils.local_path("WebHostLib", "requirements.txt")]
+        worlds_path = Utils.local_path("worlds")
+        for entry in os.listdir(worlds_path):
+            requirements_path = os.path.join(worlds_path, entry, "requirements.txt")
+            if os.path.isfile(requirements_path):
+                requirements_files.append(requirements_path)
+        for requirements_file in requirements_files:
+            with self.subTest(path=requirements_file):
+                with open(requirements_file) as f:
+                    self.assertEqual(f.read()[-1], "\n")

test/general/test_state.py

@@ -0,0 +1,29 @@
+import unittest
+
+from worlds.AutoWorld import AutoWorldRegister, call_all
+from . import setup_solo_multiworld
+
+
+class TestBase(unittest.TestCase):
+    gen_steps = (
+        "generate_early",
+        "create_regions",
+    )
+
+    test_steps = (
+        "create_items",
+        "set_rules",
+        "connect_entrances",
+        "generate_basic",
+        "pre_fill",
+    )
+
+    def test_all_state_is_available(self):
+        """Ensure all_state can be created at certain steps."""
+        for game_name, world_type in AutoWorldRegister.world_types.items():
+            with self.subTest("Game", game=game_name):
+                multiworld = setup_solo_multiworld(world_type, self.gen_steps)
+                for step in self.test_steps:
+                    with self.subTest("Step", step=step):
+                        call_all(multiworld, step)
+                        self.assertTrue(multiworld.get_all_state(False, True))

test/multiworld/test_multiworlds.py

@@ -1,5 +1,5 @@
 import unittest
-from typing import List, Tuple
+from typing import ClassVar, List, Tuple
 from unittest import TestCase
 
 from BaseClasses import CollectionState, Location, MultiWorld
@@ -7,6 +7,7 @@ from Fill import distribute_items_restrictive
 from Options import Accessibility
 from worlds.AutoWorld import AutoWorldRegister, call_all, call_single
 from ..general import gen_steps, setup_multiworld
+from ..param import classvar_matrix
 
 
 class MultiworldTestBase(TestCase):
@@ -63,15 +64,18 @@ class TestAllGamesMultiworld(MultiworldTestBase):
             self.assertTrue(self.fulfills_accessibility(), "Collected all locations, but can't beat the game")
 
 
+@classvar_matrix(game=AutoWorldRegister.world_types.keys())
 class TestTwoPlayerMulti(MultiworldTestBase):
+    game: ClassVar[str]
+
     def test_two_player_single_game_fills(self) -> None:
         """Tests that a multiworld of two players for each registered game world can generate."""
-        for world_type in AutoWorldRegister.world_types.values():
-            self.multiworld = setup_multiworld([world_type, world_type], ())
-            for world in self.multiworld.worlds.values():
-                world.options.accessibility.value = Accessibility.option_full
-            self.assertSteps(gen_steps)
-            with self.subTest("filling multiworld", games=world_type.game, seed=self.multiworld.seed):
-                distribute_items_restrictive(self.multiworld)
-                call_all(self.multiworld, "post_fill")
-                self.assertTrue(self.fulfills_accessibility(), "Collected all locations, but can't beat the game")
+        world_type = AutoWorldRegister.world_types[self.game]
+        self.multiworld = setup_multiworld([world_type, world_type], ())
+        for world in self.multiworld.worlds.values():
+            world.options.accessibility.value = Accessibility.option_full
+        self.assertSteps(gen_steps)
+        with self.subTest("filling multiworld", games=world_type.game, seed=self.multiworld.seed):
+            distribute_items_restrictive(self.multiworld)
+            call_all(self.multiworld, "post_fill")
+            self.assertTrue(self.fulfills_accessibility(), "Collected all locations, but can't beat the game")

test/param.py

@@ -0,0 +1,46 @@
+import itertools
+import sys
+from typing import Any, Callable, Iterable
+
+
+def classvar_matrix(**kwargs: Iterable[Any]) -> Callable[[type], None]:
+    """
+    Create a new class for each variation of input, allowing to generate a TestCase matrix / parametrization that
+    supports multi-threading and has better reporting for ``unittest --durations=...`` and ``pytest --durations=...``
+    than subtests.
+
+    The kwargs will be set as ClassVars in the newly created classes. Use as ::
+
+        @classvar_matrix(var_name=[value1, value2])
+        class MyTestCase(unittest.TestCase):
+            var_name: typing.ClassVar[...]
+
+    :param kwargs: A dict of ClassVars to set, where key is the variable name and value is a list of all values.
+    :return: A decorator to be applied to a class.
+    """
+    keys: tuple[str]
+    values: Iterable[Iterable[Any]]
+    keys, values = zip(*kwargs.items())
+    values = map(lambda v: sorted(v) if isinstance(v, (set, frozenset)) else v, values)
+    permutations_dicts = [dict(zip(keys, v)) for v in itertools.product(*values)]
+
+    def decorator(cls: type) -> None:
+        mod = sys.modules[cls.__module__]
+
+        for permutation in permutations_dicts:
+
+            class Unrolled(cls):  # type: ignore
+                pass
+
+            for k, v in permutation.items():
+                setattr(Unrolled, k, v)
+            params = ", ".join([f"{k}={repr(v)}" for k, v in permutation.items()])
+            params = f"{{{params}}}"
+
+            Unrolled.__module__ = cls.__module__
+            Unrolled.__qualname__ = f"{cls.__qualname__}{params}"
+            setattr(mod, f"{cls.__name__}{params}", Unrolled)
+
+        return None
+
+    return decorator

worlds/AutoWorld.py

@@ -378,6 +378,10 @@ class World(metaclass=AutoWorldRegister):
         """Method for setting the rules on the World's regions and locations."""
         pass
 
+    def connect_entrances(self) -> None:
+        """Method to finalize the source and target regions of the World's entrances"""
+        pass
+
     def generate_basic(self) -> None:
         """
         Useful for randomizing things that don't affect logic but are better to be determined before the output stage.

worlds/LauncherComponents.py

@@ -87,7 +87,7 @@ class Component:
 processes = weakref.WeakSet()
 
 
-def launch_subprocess(func: Callable, name: str = None, args: Tuple[str, ...] = ()) -> None:
+def launch_subprocess(func: Callable, name: str | None = None, args: Tuple[str, ...] = ()) -> None:
     global processes
     import multiprocessing
     process = multiprocessing.Process(target=func, name=name, args=args)
@@ -95,6 +95,14 @@ def launch_subprocess(func: Callable, name: str = None, args: Tuple[str, ...] =
     processes.add(process)
 
 
+def launch(func: Callable, name: str | None = None, args: Tuple[str, ...] = ()) -> None:
+    from Utils import is_kivy_running
+    if is_kivy_running():
+        launch_subprocess(func, name, args)
+    else:
+        func(*args)
+
+
 class SuffixIdentifier:
     suffixes: Iterable[str]
 
@@ -111,7 +119,7 @@ class SuffixIdentifier:
 
 def launch_textclient(*args):
     import CommonClient
-    launch_subprocess(CommonClient.run_as_textclient, name="TextClient", args=args)
+    launch(CommonClient.run_as_textclient, name="TextClient", args=args)
 
 
 def _install_apworld(apworld_src: str = "") -> Optional[Tuple[pathlib.Path, pathlib.Path]]:

worlds/_bizhawk/README.md

@@ -55,6 +55,7 @@ async def lock(ctx) -> None
 async def unlock(ctx) -> None
 
 async def get_hash(ctx) -> str
+async def get_memory_size(ctx, domain: str) -> int
 async def get_system(ctx) -> str
 async def get_cores(ctx) -> dict[str, str]
 async def ping(ctx) -> None
@@ -168,9 +169,10 @@ select dialog and they will be associated with BizHawkClient. This does not affe
 associate the file extension with Archipelago.
 
 `validate_rom` is called to figure out whether a given ROM belongs to your client. It will only be called when a ROM is
-running on a system you specified in your `system` class variable. In most cases, that will be a single system and you
-can be sure that you're not about to try to read from nonexistent domains or out of bounds. If you decide to claim this
-ROM as yours, this is where you should do setup for things like `items_handling`.
+running on a system you specified in your `system` class variable. Take extra care here, because your code will run
+against ROMs that you have no control over. If you're reading an address deep in ROM, you might want to check the size
+of ROM before you attempt to read it using `get_memory_size`. If you decide to claim this ROM as yours, this is where
+you should do setup for things like `items_handling`.
 
 `game_watcher` is the "main loop" of your client where you should be checking memory and sending new items to the ROM.
 `BizHawkClient` will make sure that your `game_watcher` only runs when your client has validated the ROM, and will do
@@ -268,6 +270,8 @@ server connection before trying to interact with it.
 - By default, the player will be asked to provide their slot name after connecting to the server and validating, and
 that input will be used to authenticate with the `Connect` command. You can override `set_auth` in your own client to
 set it automatically based on data in the ROM or on your client instance.
+- Use `get_memory_size` inside `validate_rom` if you need to read at large addresses, in case some other game has a
+smaller ROM size.
 - You can override `on_package` in your client to watch raw packages, but don't forget you also have access to a
 subclass of `CommonContext` and its API.
 - You can import `BizHawkClientContext` for type hints using `typing.TYPE_CHECKING`. Importing it without conditions at

worlds/_bizhawk/client.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 import abc
 from typing import TYPE_CHECKING, Any, ClassVar
 
-from worlds.LauncherComponents import Component, SuffixIdentifier, Type, components, launch_subprocess
+from worlds.LauncherComponents import Component, SuffixIdentifier, Type, components, launch as launch_component
 
 if TYPE_CHECKING:
     from .context import BizHawkClientContext
@@ -15,7 +15,7 @@ if TYPE_CHECKING:
 
 def launch_client(*args) -> None:
     from .context import launch
-    launch_subprocess(launch, name="BizHawkClient", args=args)
+    launch_component(launch, name="BizHawkClient", args=args)
 
 
 component = Component("BizHawk Client", "BizHawkClient", component_type=Type.CLIENT, func=launch_client,

worlds/_bizhawk/context.py

@@ -41,6 +41,7 @@ class BizHawkClientCommandProcessor(ClientCommandProcessor):
 
 class BizHawkClientContext(CommonContext):
     command_processor = BizHawkClientCommandProcessor
+    server_seed_name: str | None = None
     auth_status: AuthStatus
     password_requested: bool
     client_handler: BizHawkClient | None
@@ -68,6 +69,8 @@ class BizHawkClientContext(CommonContext):
         if cmd == "Connected":
             self.slot_data = args.get("slot_data", None)
             self.auth_status = AuthStatus.AUTHENTICATED
+        elif cmd == "RoomInfo":
+            self.server_seed_name = args.get("seed_name", None)
 
         if self.client_handler is not None:
             self.client_handler.on_package(self, cmd, args)
@@ -100,6 +103,7 @@ class BizHawkClientContext(CommonContext):
 
     async def disconnect(self, allow_autoreconnect: bool=False):
         self.auth_status = AuthStatus.NOT_AUTHENTICATED
+        self.server_seed_name = None
         await super().disconnect(allow_autoreconnect)
 
 
@@ -238,6 +242,7 @@ def _patch_and_run_game(patch_file: str):
         return metadata
     except Exception as exc:
         logger.exception(exc)
+        Utils.messagebox("Error Patching Game", str(exc), True)
         return {}
 
 
@@ -271,6 +276,6 @@ def launch(*launch_args: str) -> None:
 
     Utils.init_logging("BizHawkClient", exception_logger="Client")
     import colorama
-    colorama.init()
+    colorama.just_fix_windows_console()
     asyncio.run(main())
     colorama.deinit()

worlds/_sc2common/requirements.txt

@@ -3,4 +3,4 @@ mpyq>=0.2.5
 portpicker>=1.5.2
 aiohttp>=3.8.4
 loguru>=0.7.0
-protobuf==3.20.3
+protobuf==3.20.3

worlds/ahit/Client.py

@@ -261,6 +261,6 @@ def launch():
     # options = Utils.get_options()
 
     import colorama
-    colorama.init()
+    colorama.just_fix_windows_console()
     asyncio.run(main())
     colorama.deinit()

worlds/ahit/Locations.py

@@ -206,7 +206,7 @@ ahit_locations = {
     "Subcon Village - Graveyard Ice Cube": LocData(2000325077, "Subcon Forest Area"),
     "Subcon Village - House Top": LocData(2000325471, "Subcon Forest Area"),
     "Subcon Village - Ice Cube House": LocData(2000325469, "Subcon Forest Area"),
-    "Subcon Village - Snatcher Statue Chest": LocData(2000323730, "Subcon Forest Area", paintings=1),
+    "Subcon Village - Snatcher Statue Chest": LocData(2000323730, "Subcon Forest Behind Boss Firewall"),
     "Subcon Village - Stump Platform Chest": LocData(2000323729, "Subcon Forest Area"),
     "Subcon Forest - Giant Tree Climb": LocData(2000325470, "Subcon Forest Area"),
 
@@ -233,7 +233,7 @@ ahit_locations = {
     "Subcon Forest - Long Tree Climb Chest": LocData(2000323734, "Subcon Forest Area",
                                                      required_hats=[HatType.DWELLER], paintings=2),
 
-    "Subcon Forest - Boss Arena Chest": LocData(2000323735, "Subcon Forest Area"),
+    "Subcon Forest - Boss Arena Chest": LocData(2000323735, "Subcon Forest Boss Arena"),
 
     "Subcon Forest - Manor Rooftop": LocData(2000325466, "Subcon Forest Area",
                                              hit_type=HitType.dweller_bell, paintings=1),
@@ -411,7 +411,7 @@ act_completions = {
     "Act Completion (Mail Delivery Service)": LocData(2000312032, "Mail Delivery Service",
                                                       required_hats=[HatType.SPRINT]),
 
-    "Act Completion (Your Contract has Expired)": LocData(2000311390, "Your Contract has Expired",
+    "Act Completion (Your Contract has Expired)": LocData(2000311390, "Your Contract has Expired - Post Fight",
                                                           hit_type=HitType.umbrella),
 
     "Act Completion (Time Rift - Pipe)": LocData(2000313069, "Time Rift - Pipe", hookshot=True),
@@ -976,7 +976,6 @@ event_locs = {
     **snatcher_coins,
     "HUMT Access": LocData(0, "Heating Up Mafia Town"),
     "TOD Access": LocData(0, "Toilet of Doom"),
-    "YCHE Access": LocData(0, "Your Contract has Expired"),
     "AFR Access": LocData(0, "Alpine Free Roam"),
     "TIHS Access": LocData(0, "The Illness has Spread"),
 

worlds/ahit/Options.py

@@ -338,7 +338,7 @@ class MinExtraYarn(Range):
     There must be at least this much more yarn over the total number of yarn needed to craft all hats.
     For example, if this option's value is 10, and the total yarn needed to craft all hats is 40,
     there must be at least 50 yarn in the pool."""
-    display_name = "Max Extra Yarn"
+    display_name = "Min Extra Yarn"
     range_start = 5
     range_end = 15
     default = 10

worlds/ahit/Regions.py

@@ -347,7 +347,7 @@ def create_regions(world: "HatInTimeWorld"):
     sf_act3 = create_region_and_connect(world, "Toilet of Doom", "Subcon Forest - Act 3", subcon_forest)
     sf_act4 = create_region_and_connect(world, "Queen Vanessa's Manor", "Subcon Forest - Act 4", subcon_forest)
     sf_act5 = create_region_and_connect(world, "Mail Delivery Service", "Subcon Forest - Act 5", subcon_forest)
-    create_region_and_connect(world, "Your Contract has Expired", "Subcon Forest - Finale", subcon_forest)
+    sf_finale = create_region_and_connect(world, "Your Contract has Expired", "Subcon Forest - Finale", subcon_forest)
 
     # ------------------------------------------- ALPINE SKYLINE ------------------------------------------ #
     alpine_skyline = create_region_and_connect(world, "Alpine Skyline",  "Telescope -> Alpine Skyline", spaceship)
@@ -386,11 +386,24 @@ def create_regions(world: "HatInTimeWorld"):
     create_rift_connections(world, create_region(world, "Time Rift - Bazaar"))
 
     sf_area: Region = create_region(world, "Subcon Forest Area")
+    sf_behind_boss_firewall: Region = create_region(world, "Subcon Forest Behind Boss Firewall")
+    sf_boss_arena: Region = create_region(world, "Subcon Forest Boss Arena")
+    sf_area.connect(sf_behind_boss_firewall, "SF Area -> SF Behind Boss Firewall")
+    sf_behind_boss_firewall.connect(sf_boss_arena, "SF Behind Boss Firewall -> SF Boss Arena")
     sf_act1.connect(sf_area, "Subcon Forest Entrance CO")
     sf_act2.connect(sf_area, "Subcon Forest Entrance SW")
     sf_act3.connect(sf_area, "Subcon Forest Entrance TOD")
     sf_act4.connect(sf_area, "Subcon Forest Entrance QVM")
     sf_act5.connect(sf_area, "Subcon Forest Entrance MDS")
+    # YCHE puts the player directly in the boss arena, with no access to the rest of Subcon Forest by default.
+    sf_finale.connect(sf_boss_arena, "Subcon Forest Entrance YCHE")
+    # To support the Snatcher Hover expert logic for Act Completion (Your Contract has Expired), the act completion has
+    # to go in a separate region because the Snatcher Hover gives direct access to the Act Completion, but does not
+    # give access to the act itself.
+    sf_finale_post_fight: Region = create_region(world, "Your Contract has Expired - Post Fight")
+    # This connection must never have any rules placed on it because they will not be inherited when setting up act
+    # connections, only the rules for the entrances to the act and the rules for the Act Completion are inherited.
+    sf_finale.connect(sf_finale_post_fight, "YCHE -> YCHE - Post Fight")
 
     create_rift_connections(world, create_region(world, "Time Rift - Sleepy Subcon"))
     create_rift_connections(world, create_region(world, "Time Rift - Pipe"))
@@ -947,6 +960,16 @@ def get_shuffled_region(world: "HatInTimeWorld", region: str) -> str:
                     return name
 
 
+def get_region_shuffled_to(world: "HatInTimeWorld", region: str) -> str:
+    if world.options.ActRandomizer:
+        original_ci: str = chapter_act_info[region]
+        shuffled_ci = world.act_connections[original_ci]
+        return next(act_name for act_name, ci in chapter_act_info.items()
+                    if ci == shuffled_ci)
+    else:
+        return region
+
+
 def get_region_location_count(world: "HatInTimeWorld", region_name: str, included_only: bool = True) -> int:
     count = 0
     region = world.multiworld.get_region(region_name, world.player)

worlds/ahit/Rules.py

@@ -481,9 +481,8 @@ def set_hard_rules(world: "HatInTimeWorld"):
     set_rule(world.multiworld.get_location("Subcon Forest - Dweller Platforming Tree B", world.player),
              lambda state: has_paintings(state, world, 3))
 
-    # Cherry bridge over boss arena gap (painting still expected)
-    set_rule(world.multiworld.get_location("Subcon Forest - Boss Arena Chest", world.player),
-             lambda state: has_paintings(state, world, 1, False) or state.has("YCHE Access", world.player))
+    # Cherry bridge over boss arena gap
+    set_rule(world.get_entrance("SF Behind Boss Firewall -> SF Boss Arena"), lambda state: True)
 
     set_rule(world.multiworld.get_location("Subcon Forest - Noose Treehouse", world.player),
              lambda state: has_paintings(state, world, 2, True))
@@ -566,27 +565,61 @@ def set_expert_rules(world: "HatInTimeWorld"):
              lambda state: True)
 
     # Expert: Cherry Hovering
-    subcon_area = world.multiworld.get_region("Subcon Forest Area", world.player)
-    yche = world.multiworld.get_region("Your Contract has Expired", world.player)
-    entrance = yche.connect(subcon_area, "Subcon Forest Entrance YCHE")
+    # Skipping the boss firewall is possible with a Cherry Hover.
+    set_rule(world.get_entrance("SF Area -> SF Behind Boss Firewall"),
+             lambda state: has_paintings(state, world, 1, True))
+    # The boss arena gap can be crossed in reverse with a Cherry Hover.
+    subcon_boss_arena = world.get_region("Subcon Forest Boss Arena")
+    subcon_behind_boss_firewall = world.get_region("Subcon Forest Behind Boss Firewall")
+    subcon_boss_arena.connect(subcon_behind_boss_firewall, "SF Boss Arena -> SF Behind Boss Firewall")
 
-    if world.options.NoPaintingSkips:
-        add_rule(entrance, lambda state: has_paintings(state, world, 1))
+    subcon_area = world.get_region("Subcon Forest Area")
+
+    # The boss firewall can be skipped in reverse with a Cherry Hover, but it is not possible to remove the boss
+    # firewall from reverse because the paintings to burn to remove the firewall are on the other side of the firewall.
+    # Therefore, a painting skip is required. The paintings could be burned by already having access to
+    # "Subcon Forest Area" through another entrance, but making a new connection to "Subcon Forest Area" in that case
+    # would be pointless.
+    if not world.options.NoPaintingSkips:
+        # The import cannot be done at the module-level because it would cause a circular import.
+        from .Regions import get_region_shuffled_to
+
+        subcon_behind_boss_firewall.connect(subcon_area, "SF Behind Boss Firewall -> SF Area")
+
+        # Because the Your Contract has Expired entrance can now reach "Subcon Forest Area", it needs to be connected to
+        # each of the Subcon Forest Time Rift entrances, like the other Subcon Forest Acts.
+        yche = world.get_region("Your Contract has Expired")
+
+        def connect_to_shuffled_act_at(original_act_name):
+            region_name = get_region_shuffled_to(world, original_act_name)
+            return yche.connect(world.get_region(region_name), f"{original_act_name} Portal - Entrance YCHE")
+
+        # Rules copied from `Rules.set_rift_rules()` with painting logic removed because painting skips must be
+        # available.
+        entrance = connect_to_shuffled_act_at("Time Rift - Pipe")
+        add_rule(entrance, lambda state: can_clear_required_act(state, world, "Subcon Forest - Act 2"))
+        reg_act_connection(world, world.get_entrance("Subcon Forest - Act 2").connected_region, entrance)
+
+        entrance = connect_to_shuffled_act_at("Time Rift - Village")
+        add_rule(entrance, lambda state: can_clear_required_act(state, world, "Subcon Forest - Act 4"))
+        reg_act_connection(world, world.get_entrance("Subcon Forest - Act 4").connected_region, entrance)
+
+        entrance = connect_to_shuffled_act_at("Time Rift - Sleepy Subcon")
+        add_rule(entrance, lambda state: has_relic_combo(state, world, "UFO"))
 
     set_rule(world.multiworld.get_location("Act Completion (Toilet of Doom)", world.player),
              lambda state: can_use_hookshot(state, world) and can_hit(state, world)
              and has_paintings(state, world, 1, True))
 
     # Set painting rules only. Skipping paintings is determined in has_paintings
-    set_rule(world.multiworld.get_location("Subcon Forest - Boss Arena Chest", world.player),
-             lambda state: has_paintings(state, world, 1, True))
     set_rule(world.multiworld.get_location("Subcon Forest - Magnet Badge Bush", world.player),
              lambda state: has_paintings(state, world, 3, True))
 
     # You can cherry hover to Snatcher's post-fight cutscene, which completes the level without having to fight him
-    subcon_area.connect(yche, "Snatcher Hover")
-    set_rule(world.multiworld.get_location("Act Completion (Your Contract has Expired)", world.player),
-             lambda state: True)
+    yche_post_fight = world.get_region("Your Contract has Expired - Post Fight")
+    subcon_area.connect(yche_post_fight, "Snatcher Hover")
+    # Cherry Hover from YCHE also works, so there are no requirements for the Act Completion.
+    set_rule(world.get_location("Act Completion (Your Contract has Expired)"), lambda state: True)
 
     if world.is_dlc2():
         # Expert: clear Rush Hour with nothing
@@ -681,12 +714,18 @@ def set_subcon_rules(world: "HatInTimeWorld"):
              lambda state: can_use_hat(state, world, HatType.BREWING) or state.has("Umbrella", world.player)
              or can_use_hat(state, world, HatType.DWELLER))
 
-    # You can't skip over the boss arena wall without cherry hover, so these two need to be set this way
-    set_rule(world.multiworld.get_location("Subcon Forest - Boss Arena Chest", world.player),
-             lambda state: state.has("TOD Access", world.player) and can_use_hookshot(state, world)
-             and has_paintings(state, world, 1, False) or state.has("YCHE Access", world.player))
+    # You can't skip over the boss arena wall without cherry hover.
+    set_rule(world.get_entrance("SF Area -> SF Behind Boss Firewall"),
+             lambda state: has_paintings(state, world, 1, False))
 
-    # The painting wall can't be skipped without cherry hover, which is Expert
+    # The hookpoints to cross the boss arena gap are only present in Toilet of Doom.
+    set_rule(world.get_entrance("SF Behind Boss Firewall -> SF Boss Arena"),
+             lambda state: state.has("TOD Access", world.player)
+             and can_use_hookshot(state, world))
+
+    # The Act Completion is in the Toilet of Doom region, so the same rules as passing the boss firewall and crossing
+    # the boss arena gap are required. "TOD Access" is implied from the region so does not need to be included in the
+    # rule.
     set_rule(world.multiworld.get_location("Act Completion (Toilet of Doom)", world.player),
              lambda state: can_use_hookshot(state, world) and can_hit(state, world)
              and has_paintings(state, world, 1, False))

worlds/ahit/__init__.py

@@ -12,13 +12,13 @@ from .DeathWishRules import set_dw_rules, create_enemy_events, hit_list, bosses
 from worlds.AutoWorld import World, WebWorld, CollectionState
 from worlds.generic.Rules import add_rule
 from typing import List, Dict, TextIO
-from worlds.LauncherComponents import Component, components, icon_paths, launch_subprocess, Type
+from worlds.LauncherComponents import Component, components, icon_paths, launch as launch_component, Type
 from Utils import local_path
 
 
 def launch_client():
     from .Client import launch
-    launch_subprocess(launch, name="AHITClient")
+    launch_component(launch, name="AHITClient")
 
 
 components.append(Component("A Hat in Time Client", "AHITClient", func=launch_client,

worlds/ahit/docs/setup_en.md

@@ -21,7 +21,7 @@
 
 
 3. Click the **Betas** tab. In the **Beta Participation** dropdown, select `tcplink`.  
-   While it downloads, you can subscribe to the [Archipelago workshop mod.]((https://steamcommunity.com/sharedfiles/filedetails/?id=3026842601))
+   While it downloads, you can subscribe to the [Archipelago workshop mod](https://steamcommunity.com/sharedfiles/filedetails/?id=3026842601).
 
 
 4. Once the game finishes downloading, start it up.  
@@ -62,4 +62,4 @@ The level that the relic set unlocked will stay unlocked.
 
 ### When I start a new save file, the intro cinematic doesn't get skipped, Hat Kid's body is missing and the mod doesn't work!
 There is a bug on older versions of A Hat in Time that causes save file creation to fail to work properly 
-if you have too many save files. Delete them and it should fix the problem.
+if you have too many save files. Delete them and it should fix the problem.

worlds/alttp/Rom.py

@@ -515,10 +515,15 @@ def _populate_sprite_table():
                     logging.debug(f"Spritefile {file} could not be loaded as a valid sprite.")
 
             with concurrent.futures.ThreadPoolExecutor() as pool:
-                for dir in [user_path('data', 'sprites', 'alttpr'), user_path('data', 'sprites', 'custom')]:
+                sprite_paths = [user_path('data', 'sprites', 'alttpr'), user_path('data', 'sprites', 'custom')]
+                for dir in [dir for dir in sprite_paths if os.path.isdir(dir)]:
                     for file in os.listdir(dir):
                         pool.submit(load_sprite_from_file, os.path.join(dir, file))
 
+            if "link" not in _sprite_table:
+                logging.info("Link sprite was not loaded. Loading link from base rom")
+                load_sprite_from_file(get_base_rom_path())
+
 
 class Sprite():
     sprite_size = 28672
@@ -554,6 +559,11 @@ class Sprite():
             self.sprite = filedata[0x80000:0x87000]
             self.palette = filedata[0xDD308:0xDD380]
             self.glove_palette = filedata[0xDEDF5:0xDEDF9]
+            h = hashlib.md5()
+            h.update(filedata)
+            if h.hexdigest() == LTTPJPN10HASH:
+                self.name = "Link"
+                self.author_name = "Nintendo"
         elif filedata.startswith(b'ZSPR'):
             self.from_zspr(filedata, filename)
         else:
@@ -1547,9 +1557,9 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
     rom.write_byte(0x18003B, 0x01 if world.map_shuffle[player] else 0x00)  # maps showing crystals on overworld
 
     # compasses showing dungeon count
-    if local_world.clock_mode or not world.dungeon_counters[player]:
+    if local_world.clock_mode or world.dungeon_counters[player] == 'off':
         rom.write_byte(0x18003C, 0x00)  # Currently must be off if timer is on, because they use same HUD location
-    elif world.dungeon_counters[player] is True:
+    elif world.dungeon_counters[player] == 'on':
         rom.write_byte(0x18003C, 0x02)  # always on
     elif world.compass_shuffle[player] or world.dungeon_counters[player] == 'pickup':
         rom.write_byte(0x18003C, 0x01)  # show on pickup

worlds/alttp/Rules.py

@@ -1120,28 +1120,28 @@ def toss_junk_item(world, player):
     raise Exception("Unable to find a junk item to toss to make room for a TR small key")
 
 
-def set_trock_key_rules(world, player):
+def set_trock_key_rules(multiworld, player):
     # First set all relevant locked doors to impassible.
     for entrance in ['Turtle Rock Dark Room Staircase', 'Turtle Rock (Chain Chomp Room) (North)', 'Turtle Rock (Chain Chomp Room) (South)', 'Turtle Rock Entrance to Pokey Room', 'Turtle Rock (Pokey Room) (South)', 'Turtle Rock (Pokey Room) (North)', 'Turtle Rock Big Key Door']:
-        set_rule(world.get_entrance(entrance, player), lambda state: False)
+        set_rule(multiworld.get_entrance(entrance, player), lambda state: False)
 
-    all_state = world.get_all_state(use_cache=False)
+    all_state = multiworld.get_all_state(use_cache=False, allow_partial_entrances=True)
     all_state.reachable_regions[player] = set()  # wipe reachable regions so that the locked doors actually work
     all_state.stale[player] = True
 
     # Check if each of the four main regions of the dungoen can be reached. The previous code section prevents key-costing moves within the dungeon.
-    can_reach_back = all_state.can_reach(world.get_region('Turtle Rock (Eye Bridge)', player))
-    can_reach_front = all_state.can_reach(world.get_region('Turtle Rock (Entrance)', player))
-    can_reach_big_chest = all_state.can_reach(world.get_region('Turtle Rock (Big Chest)', player))
-    can_reach_middle = all_state.can_reach(world.get_region('Turtle Rock (Second Section)', player))
+    can_reach_back = all_state.can_reach(multiworld.get_region('Turtle Rock (Eye Bridge)', player))
+    can_reach_front = all_state.can_reach(multiworld.get_region('Turtle Rock (Entrance)', player))
+    can_reach_big_chest = all_state.can_reach(multiworld.get_region('Turtle Rock (Big Chest)', player))
+    can_reach_middle = all_state.can_reach(multiworld.get_region('Turtle Rock (Second Section)', player))
 
     # If you can't enter from the back, the door to the front of TR requires only 2 small keys if the big key is in one of these chests since 2 key doors are locked behind the big key door.
     # If you can only enter from the middle, this includes all locations that can only be reached by exiting the front.  This can include Laser Bridge and Crystaroller if the front and back connect via Dark DM Ledge!
     front_locked_locations = {('Turtle Rock - Compass Chest', player), ('Turtle Rock - Roller Room - Left', player), ('Turtle Rock - Roller Room - Right', player)}
     if can_reach_middle and not can_reach_back and not can_reach_front:
         normal_regions = all_state.reachable_regions[player].copy()
-        set_rule(world.get_entrance('Turtle Rock (Chain Chomp Room) (South)', player), lambda state: True)
-        set_rule(world.get_entrance('Turtle Rock (Pokey Room) (South)', player), lambda state: True)
+        set_rule(multiworld.get_entrance('Turtle Rock (Chain Chomp Room) (South)', player), lambda state: True)
+        set_rule(multiworld.get_entrance('Turtle Rock (Pokey Room) (South)', player), lambda state: True)
         all_state.update_reachable_regions(player)
         front_locked_regions = all_state.reachable_regions[player].difference(normal_regions)
         front_locked_locations = set((location.name, player) for region in front_locked_regions for location in region.locations)
@@ -1151,37 +1151,38 @@ def set_trock_key_rules(world, player):
 
     # Big key door requires the big key, obviously. We removed this rule in the previous section to flag front_locked_locations correctly,
     # otherwise crystaroller room might not be properly marked as reachable through the back.
-    set_rule(world.get_entrance('Turtle Rock Big Key Door', player), lambda state: state.has('Big Key (Turtle Rock)', player))
+    set_rule(multiworld.get_entrance('Turtle Rock Big Key Door', player), lambda state: state.has('Big Key (Turtle Rock)', player) and can_kill_most_things(state, player, 10) and can_bomb_or_bonk(state, player))
+
 
     # No matter what, the key requirement for going from the middle to the bottom should be five keys.
-    set_rule(world.get_entrance('Turtle Rock Dark Room Staircase', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 5))
+    set_rule(multiworld.get_entrance('Turtle Rock Dark Room Staircase', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 5))
 
     # Now we need to set rules based on which entrances we have access to. The most important point is whether we have back access. If we have back access, we
     # might open all the locked doors in any order, so we need maximally restrictive rules.
     if can_reach_back:
-        set_rule(world.get_location('Turtle Rock - Big Key Chest', player), lambda state: (state._lttp_has_key('Small Key (Turtle Rock)', player, 6) or location_item_name(state, 'Turtle Rock - Big Key Chest', player) == ('Small Key (Turtle Rock)', player)))
-        set_rule(world.get_entrance('Turtle Rock (Chain Chomp Room) (South)', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 5))
-        set_rule(world.get_entrance('Turtle Rock (Pokey Room) (South)', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 6))
+        set_rule(multiworld.get_location('Turtle Rock - Big Key Chest', player), lambda state: (state._lttp_has_key('Small Key (Turtle Rock)', player, 6) or location_item_name(state, 'Turtle Rock - Big Key Chest', player) == ('Small Key (Turtle Rock)', player)))
+        set_rule(multiworld.get_entrance('Turtle Rock (Chain Chomp Room) (South)', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 5))
+        set_rule(multiworld.get_entrance('Turtle Rock (Pokey Room) (South)', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 6))
 
-        set_rule(world.get_entrance('Turtle Rock (Chain Chomp Room) (North)', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 6))
-        set_rule(world.get_entrance('Turtle Rock (Pokey Room) (North)', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 6))
-        set_rule(world.get_entrance('Turtle Rock Entrance to Pokey Room', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 5))
+        set_rule(multiworld.get_entrance('Turtle Rock (Chain Chomp Room) (North)', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 6))
+        set_rule(multiworld.get_entrance('Turtle Rock (Pokey Room) (North)', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 6))
+        set_rule(multiworld.get_entrance('Turtle Rock Entrance to Pokey Room', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 5))
     else:
         # Middle to front requires 3 keys if the back is locked by this door, otherwise 5
-        set_rule(world.get_entrance('Turtle Rock (Chain Chomp Room) (South)', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 3)
+        set_rule(multiworld.get_entrance('Turtle Rock (Chain Chomp Room) (South)', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 3)
                 if item_name_in_location_names(state, 'Big Key (Turtle Rock)', player, front_locked_locations.union({('Turtle Rock - Pokey 1 Key Drop', player)}))
                 else state._lttp_has_key('Small Key (Turtle Rock)', player, 5))
         # Middle to front requires 4 keys if the back is locked by this door, otherwise 6
-        set_rule(world.get_entrance('Turtle Rock (Pokey Room) (South)', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 4)
+        set_rule(multiworld.get_entrance('Turtle Rock (Pokey Room) (South)', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 4)
                 if item_name_in_location_names(state, 'Big Key (Turtle Rock)', player, front_locked_locations)
                 else state._lttp_has_key('Small Key (Turtle Rock)', player, 6))
 
         # Front to middle requires 3 keys (if the middle is accessible then these doors can be avoided, otherwise no keys can be wasted)
-        set_rule(world.get_entrance('Turtle Rock (Chain Chomp Room) (North)', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 3))
-        set_rule(world.get_entrance('Turtle Rock (Pokey Room) (North)', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 2))
-        set_rule(world.get_entrance('Turtle Rock Entrance to Pokey Room', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 1))
+        set_rule(multiworld.get_entrance('Turtle Rock (Chain Chomp Room) (North)', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 3))
+        set_rule(multiworld.get_entrance('Turtle Rock (Pokey Room) (North)', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 2))
+        set_rule(multiworld.get_entrance('Turtle Rock Entrance to Pokey Room', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, 1))
 
-        set_rule(world.get_location('Turtle Rock - Big Key Chest', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, tr_big_key_chest_keys_needed(state)))
+        set_rule(multiworld.get_location('Turtle Rock - Big Key Chest', player), lambda state: state._lttp_has_key('Small Key (Turtle Rock)', player, tr_big_key_chest_keys_needed(state)))
 
         def tr_big_key_chest_keys_needed(state):
             # This function handles the key requirements for the TR Big Chest in the situations it having the Big Key should logically require 2 keys, small key
@@ -1194,30 +1195,30 @@ def set_trock_key_rules(world, player):
             return 6
 
         # If TR is only accessible from the middle, the big key must be further restricted to prevent softlock potential
-        if not can_reach_front and not world.small_key_shuffle[player]:
+        if not can_reach_front and not multiworld.small_key_shuffle[player]:
             # Must not go in the Big Key Chest - only 1 other chest available and 2+ keys required for all other chests
-            forbid_item(world.get_location('Turtle Rock - Big Key Chest', player), 'Big Key (Turtle Rock)', player)
+            forbid_item(multiworld.get_location('Turtle Rock - Big Key Chest', player), 'Big Key (Turtle Rock)', player)
             if not can_reach_big_chest:
                 # Must not go in the Chain Chomps chest - only 2 other chests available and 3+ keys required for all other chests
-                forbid_item(world.get_location('Turtle Rock - Chain Chomps', player), 'Big Key (Turtle Rock)', player)
-                forbid_item(world.get_location('Turtle Rock - Pokey 2 Key Drop', player), 'Big Key (Turtle Rock)', player)
-            if world.accessibility[player] == 'full':
-                if world.big_key_shuffle[player] and can_reach_big_chest:
+                forbid_item(multiworld.get_location('Turtle Rock - Chain Chomps', player), 'Big Key (Turtle Rock)', player)
+                forbid_item(multiworld.get_location('Turtle Rock - Pokey 2 Key Drop', player), 'Big Key (Turtle Rock)', player)
+            if multiworld.accessibility[player] == 'full':
+                if multiworld.big_key_shuffle[player] and can_reach_big_chest:
                     # Must not go in the dungeon - all 3 available chests (Chomps, Big Chest, Crystaroller) must be keys to access laser bridge, and the big key is required first
                     for location in ['Turtle Rock - Chain Chomps', 'Turtle Rock - Compass Chest',
                                      'Turtle Rock - Pokey 1 Key Drop', 'Turtle Rock - Pokey 2 Key Drop',
                                      'Turtle Rock - Roller Room - Left', 'Turtle Rock - Roller Room - Right']:
-                        forbid_item(world.get_location(location, player), 'Big Key (Turtle Rock)', player)
+                        forbid_item(multiworld.get_location(location, player), 'Big Key (Turtle Rock)', player)
                 else:
                     # A key is required in the Big Key Chest to prevent a possible softlock.  Place an extra key to ensure 100% locations still works
-                    item = item_factory('Small Key (Turtle Rock)', world.worlds[player])
-                    location = world.get_location('Turtle Rock - Big Key Chest', player)
+                    item = item_factory('Small Key (Turtle Rock)', multiworld.worlds[player])
+                    location = multiworld.get_location('Turtle Rock - Big Key Chest', player)
                     location.place_locked_item(item)
-                    toss_junk_item(world, player)
+                    toss_junk_item(multiworld, player)
 
-    if world.accessibility[player] != 'full':
-        set_always_allow(world.get_location('Turtle Rock - Big Key Chest', player), lambda state, item: item.name == 'Small Key (Turtle Rock)' and item.player == player
-                and state.can_reach(state.multiworld.get_region('Turtle Rock (Second Section)', player)))
+    if multiworld.accessibility[player] != 'full':
+        set_always_allow(multiworld.get_location('Turtle Rock - Big Key Chest', player), lambda state, item: item.name == 'Small Key (Turtle Rock)' and item.player == player
+                                                                                                             and state.can_reach(state.multiworld.get_region('Turtle Rock (Second Section)', player)))
 
 
 def set_big_bomb_rules(world, player):

worlds/alttp/requirements.txt

@@ -1,2 +1,2 @@
 maseya-z3pr>=1.0.0rc1
-xxtea>=3.0.0
+xxtea>=3.0.0

worlds/alttp/test/inverted/TestInvertedTurtleRock.py

@@ -79,12 +79,12 @@ class TestInvertedTurtleRock(TestInverted):
             ["Turtle Rock - Crystaroller Room", False, [], ['Big Key (Turtle Rock)', 'Lamp']],
             ["Turtle Rock - Crystaroller Room", False, [], ['Magic Mirror', 'Cane of Somaria']],
             ["Turtle Rock - Crystaroller Room", False, ['Small Key (Turtle Rock)', 'Small Key (Turtle Rock)'], ['Magic Mirror', 'Small Key (Turtle Rock)']],
-            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Flute', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)']],
-            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)']],
-            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Lamp', 'Magic Mirror', 'Progressive Glove', 'Progressive Glove']],
-            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Lamp', 'Magic Mirror', 'Progressive Glove', 'Moon Pearl', 'Hookshot']],
-            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Moon Pearl', 'Flute', 'Magic Mirror', 'Hookshot']],
-            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Flute', 'Progressive Glove', 'Progressive Glove', 'Magic Mirror']],
+            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Flute', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)']],
+            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)']],
+            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Lamp', 'Magic Mirror', 'Progressive Glove', 'Progressive Glove']],
+            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Lamp', 'Magic Mirror', 'Progressive Glove', 'Moon Pearl', 'Hookshot']],
+            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Moon Pearl', 'Flute', 'Magic Mirror', 'Hookshot']],
+            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Flute', 'Progressive Glove', 'Progressive Glove', 'Magic Mirror']],
             ["Turtle Rock - Crystaroller Room", True, ['Lamp', 'Magic Mirror', 'Progressive Glove', 'Progressive Glove', 'Cane of Somaria']],
             ["Turtle Rock - Crystaroller Room", True, ['Lamp', 'Magic Mirror', 'Progressive Glove', 'Moon Pearl', 'Hookshot', 'Cane of Somaria']],
             ["Turtle Rock - Crystaroller Room", True, ['Lamp', 'Moon Pearl', 'Flute', 'Magic Mirror', 'Hookshot', 'Cane of Somaria']],
@@ -97,9 +97,9 @@ class TestInvertedTurtleRock(TestInverted):
             ["Turtle Rock - Boss", False, [], ['Big Key (Turtle Rock)']],
             ["Turtle Rock - Boss", False, [], ['Magic Mirror', 'Lamp']],
             ["Turtle Rock - Boss", False, ['Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)'], ['Small Key (Turtle Rock)']],
-            ["Turtle Rock - Boss", True, ['Ice Rod', 'Fire Rod', 'Lamp', 'Flute', 'Quake', 'Progressive Sword', 'Progressive Sword', 'Cane of Somaria', 'Bottle', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Big Key (Turtle Rock)']],
-            ["Turtle Rock - Boss", True, ['Ice Rod', 'Fire Rod', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Progressive Sword', 'Cane of Somaria', 'Bottle', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Big Key (Turtle Rock)']],
-            ["Turtle Rock - Boss", True, ['Ice Rod', 'Fire Rod', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Progressive Sword', 'Cane of Somaria', 'Magic Upgrade (1/2)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)','Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Big Key (Turtle Rock)']],
+            ["Turtle Rock - Boss", True, ['Ice Rod', 'Fire Rod', 'Lamp', 'Flute', 'Quake', 'Progressive Sword', 'Progressive Sword', 'Cane of Somaria', 'Bottle', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Big Key (Turtle Rock)']],
+            ["Turtle Rock - Boss", True, ['Ice Rod', 'Fire Rod', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Progressive Sword', 'Cane of Somaria', 'Bottle', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Big Key (Turtle Rock)']],
+            ["Turtle Rock - Boss", True, ['Ice Rod', 'Fire Rod', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Progressive Sword', 'Cane of Somaria', 'Magic Upgrade (1/2)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)','Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Big Key (Turtle Rock)']],
             ["Turtle Rock - Boss", True, ['Ice Rod', 'Fire Rod', 'Lamp', 'Magic Mirror', 'Progressive Glove', 'Progressive Glove', 'Hammer', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Big Key (Turtle Rock)']],
             ["Turtle Rock - Boss", True, ['Ice Rod', 'Fire Rod', 'Flute', 'Magic Mirror', 'Moon Pearl', 'Hookshot', 'Hammer', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Big Key (Turtle Rock)']]
 
@@ -117,12 +117,12 @@ class TestInvertedTurtleRock(TestInverted):
             [location, False, [], ['Magic Mirror', 'Cane of Somaria']],
             [location, False, [], ['Magic Mirror', 'Lamp']],
             [location, False, ['Small Key (Turtle Rock)', 'Small Key (Turtle Rock)'], ['Magic Mirror', 'Small Key (Turtle Rock)']],
-            [location, True, ['Big Key (Turtle Rock)', 'Flute', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Lamp', 'Cane of Byrna']],
-            [location, True, ['Big Key (Turtle Rock)', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Cane of Byrna']],
-            [location, True, ['Big Key (Turtle Rock)', 'Flute', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Lamp', 'Cape']],
-            [location, True, ['Big Key (Turtle Rock)', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Cape']],
-            [location, True, ['Big Key (Turtle Rock)', 'Flute', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Lamp', 'Progressive Shield', 'Progressive Shield', 'Progressive Shield']],
-            [location, True, ['Big Key (Turtle Rock)', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Progressive Shield', 'Progressive Shield', 'Progressive Shield']],
+            [location, True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Flute', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Lamp', 'Cane of Byrna']],
+            [location, True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Cane of Byrna']],
+            [location, True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Flute', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Lamp', 'Cape']],
+            [location, True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Cape']],
+            [location, True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Flute', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Lamp', 'Progressive Shield', 'Progressive Shield', 'Progressive Shield']],
+            [location, True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Progressive Shield', 'Progressive Shield', 'Progressive Shield']],
 
             # Mirroring into Eye Bridge does not require Cane of Somaria
             [location, True, ['Lamp', 'Magic Mirror', 'Progressive Glove', 'Progressive Glove', 'Cane of Byrna']],

worlds/alttp/test/inverted_minor_glitches/TestInvertedTurtleRock.py

@@ -80,12 +80,12 @@ class TestInvertedTurtleRock(TestInvertedMinor):
             ["Turtle Rock - Crystaroller Room", False, [], ['Big Key (Turtle Rock)', 'Lamp']],
             ["Turtle Rock - Crystaroller Room", False, [], ['Magic Mirror', 'Cane of Somaria']],
             ["Turtle Rock - Crystaroller Room", False, ['Small Key (Turtle Rock)', 'Small Key (Turtle Rock)'], ['Magic Mirror', 'Small Key (Turtle Rock)']],
-            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Flute', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)']],
-            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)']],
-            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Lamp', 'Magic Mirror', 'Progressive Glove', 'Progressive Glove']],
-            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Lamp', 'Magic Mirror', 'Progressive Glove', 'Moon Pearl', 'Hookshot']],
-            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Moon Pearl', 'Flute', 'Magic Mirror', 'Hookshot']],
-            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Flute', 'Progressive Glove', 'Progressive Glove', 'Magic Mirror']],
+            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Flute', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)']],
+            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)']],
+            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Lamp', 'Magic Mirror', 'Progressive Glove', 'Progressive Glove']],
+            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Lamp', 'Magic Mirror', 'Progressive Glove', 'Moon Pearl', 'Hookshot']],
+            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Moon Pearl', 'Flute', 'Magic Mirror', 'Hookshot']],
+            ["Turtle Rock - Crystaroller Room", True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Flute', 'Progressive Glove', 'Progressive Glove', 'Magic Mirror']],
             ["Turtle Rock - Crystaroller Room", True, ['Lamp', 'Magic Mirror', 'Progressive Glove', 'Progressive Glove', 'Cane of Somaria']],
             ["Turtle Rock - Crystaroller Room", True, ['Lamp', 'Magic Mirror', 'Progressive Glove', 'Moon Pearl', 'Hookshot', 'Cane of Somaria']],
             ["Turtle Rock - Crystaroller Room", True, ['Lamp', 'Moon Pearl', 'Flute', 'Magic Mirror', 'Hookshot', 'Cane of Somaria']],
@@ -98,9 +98,9 @@ class TestInvertedTurtleRock(TestInvertedMinor):
             ["Turtle Rock - Boss", False, [], ['Big Key (Turtle Rock)']],
             ["Turtle Rock - Boss", False, [], ['Magic Mirror', 'Lamp']],
             ["Turtle Rock - Boss", False, ['Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)'], ['Small Key (Turtle Rock)']],
-            ["Turtle Rock - Boss", True, ['Ice Rod', 'Fire Rod', 'Lamp', 'Flute', 'Quake', 'Progressive Sword', 'Progressive Sword', 'Cane of Somaria', 'Bottle', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Big Key (Turtle Rock)']],
-            ["Turtle Rock - Boss", True, ['Ice Rod', 'Fire Rod', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Progressive Sword', 'Cane of Somaria', 'Bottle', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Big Key (Turtle Rock)']],
-            ["Turtle Rock - Boss", True, ['Ice Rod', 'Fire Rod', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Progressive Sword', 'Cane of Somaria', 'Magic Upgrade (1/2)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)','Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Big Key (Turtle Rock)']],
+            ["Turtle Rock - Boss", True, ['Ice Rod', 'Fire Rod', 'Lamp', 'Flute', 'Quake', 'Progressive Sword', 'Progressive Sword', 'Cane of Somaria', 'Bottle', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Big Key (Turtle Rock)']],
+            ["Turtle Rock - Boss", True, ['Ice Rod', 'Fire Rod', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Progressive Sword', 'Cane of Somaria', 'Bottle', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Big Key (Turtle Rock)']],
+            ["Turtle Rock - Boss", True, ['Ice Rod', 'Fire Rod', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Progressive Sword', 'Cane of Somaria', 'Magic Upgrade (1/2)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)','Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Big Key (Turtle Rock)']],
             ["Turtle Rock - Boss", True, ['Ice Rod', 'Fire Rod', 'Lamp', 'Magic Mirror', 'Progressive Glove', 'Progressive Glove', 'Hammer', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Big Key (Turtle Rock)']],
             ["Turtle Rock - Boss", True, ['Ice Rod', 'Fire Rod', 'Flute', 'Magic Mirror', 'Moon Pearl', 'Hookshot', 'Hammer', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Big Key (Turtle Rock)']]
         ])
@@ -116,12 +116,12 @@ class TestInvertedTurtleRock(TestInvertedMinor):
             [location, False, [], ['Magic Mirror', 'Cane of Somaria']],
             [location, False, [], ['Magic Mirror', 'Lamp']],
             [location, False, ['Small Key (Turtle Rock)', 'Small Key (Turtle Rock)'], ['Magic Mirror', 'Small Key (Turtle Rock)']],
-            [location, True, ['Big Key (Turtle Rock)', 'Flute', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Lamp', 'Cane of Byrna']],
-            [location, True, ['Big Key (Turtle Rock)', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Cane of Byrna']],
-            [location, True, ['Big Key (Turtle Rock)', 'Flute', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Lamp', 'Cape']],
-            [location, True, ['Big Key (Turtle Rock)', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Cape']],
-            [location, True, ['Big Key (Turtle Rock)', 'Flute', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Lamp', 'Progressive Shield', 'Progressive Shield', 'Progressive Shield']],
-            [location, True, ['Big Key (Turtle Rock)', 'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Progressive Shield', 'Progressive Shield', 'Progressive Shield']],
+            [location, True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)', 'Flute', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Lamp', 'Cane of Byrna']],
+            [location, True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)',  'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Cane of Byrna']],
+            [location, True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)',  'Flute', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Lamp', 'Cape']],
+            [location, True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)',  'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Cape']],
+            [location, True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)',  'Flute', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Lamp', 'Progressive Shield', 'Progressive Shield', 'Progressive Shield']],
+            [location, True, ['Big Key (Turtle Rock)', 'Bomb Upgrade (50)',  'Lamp', 'Progressive Glove', 'Quake', 'Progressive Sword', 'Cane of Somaria', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Small Key (Turtle Rock)', 'Progressive Shield', 'Progressive Shield', 'Progressive Shield']],
 
             # Mirroring into Eye Bridge does not require Cane of Somaria
             [location, True, ['Lamp', 'Magic Mirror', 'Progressive Glove', 'Progressive Glove', 'Cane of Byrna']],

worlds/alttp/test/inverted_owg/TestDungeons.py

@@ -102,7 +102,7 @@ class TestDungeons(TestInvertedOWG):
             ["Turtle Rock - Chain Chomps", True, ['Progressive Sword', 'Progressive Sword', 'Pegasus Boots']],
 
             ["Turtle Rock - Crystaroller Room", False, []],
-            ["Turtle Rock - Crystaroller Room", True, ['Pegasus Boots', 'Magic Mirror', 'Moon Pearl', 'Big Key (Turtle Rock)']],
+            ["Turtle Rock - Crystaroller Room", True, ['Pegasus Boots', 'Magic Mirror', 'Moon Pearl', 'Big Key (Turtle Rock)', 'Bomb Upgrade (50)']],
             ["Turtle Rock - Crystaroller Room", True, ['Pegasus Boots', 'Magic Mirror', 'Moon Pearl', 'Lamp', 'Cane of Somaria']],
 
             ["Ganons Tower - Hope Room - Left", False, []],

worlds/alttp/test/owg/TestDungeons.py

@@ -120,8 +120,8 @@ class TestDungeons(TestVanillaOWG):
             #todo: does clip require sword?
             #["Turtle Rock - Crystaroller Room", True, ['Moon Pearl', 'Pegasus Boots', 'Big Key (Turtle Rock)']],
             ["Turtle Rock - Crystaroller Room", True, ['Moon Pearl', 'Pegasus Boots', 'Big Key (Turtle Rock)', 'Progressive Sword']],
-            ["Turtle Rock - Crystaroller Room", True, ['Moon Pearl', 'Pegasus Boots', 'Big Key (Turtle Rock)', 'Hookshot']],
-            ["Turtle Rock - Crystaroller Room", True, ['Pegasus Boots', 'Magic Mirror', 'Big Key (Turtle Rock)']],
+            ["Turtle Rock - Crystaroller Room", True, ['Moon Pearl', 'Pegasus Boots', 'Big Key (Turtle Rock)', 'Hookshot', 'Bomb Upgrade (50)']],
+            ["Turtle Rock - Crystaroller Room", True, ['Pegasus Boots', 'Magic Mirror', 'Big Key (Turtle Rock)', 'Bomb Upgrade (50)']],
 
             ["Ganons Tower - Hope Room - Left", False, []],
             ["Ganons Tower - Hope Room - Left", False, ['Moon Pearl', 'Crystal 1']],

worlds/blasphemous/Locations.py

@@ -89,7 +89,7 @@ location_names: Dict[str, str] = {
     "RESCUED_CHERUB_15": "DC: Top of elevator Child of Moonlight",
     "Lady[D01Z05S22]":   "DC: Lady of the Six Sorrows, from MD",
     "QI75":              "DC: Chalice room",
-    "Sword[D01Z05S24]":  "DC: Mea culpa altar",
+    "Sword[D01Z05S24]":  "DC: Mea Culpa altar",
     "CO44":              "DC: Elevator shaft ledge",
     "RESCUED_CHERUB_22": "DC: Elevator shaft Child of Moonlight",
     "Lady[D01Z05S26]":   "DC: Lady of the Six Sorrows, elevator shaft",

worlds/blasphemous/__init__.py

@@ -67,7 +67,8 @@ class BlasphemousWorld(World):
 
     def generate_early(self):
         if not self.options.starting_location.randomized:
-            if self.options.starting_location == "mourning_havoc" and self.options.difficulty < 2:
+            if (self.options.starting_location == "knot_of_words" or self.options.starting_location == "rooftops" \
+                or self.options.starting_location == "mourning_havoc") and self.options.difficulty < 2:
                 raise OptionError(f"[Blasphemous - '{self.player_name}'] "
                                 f"{self.options.starting_location} cannot be chosen if Difficulty is lower than Hard.")
 
@@ -83,6 +84,8 @@ class BlasphemousWorld(World):
             locations: List[int] = [ 0, 1, 2, 3, 4, 5, 6 ]
 
             if self.options.difficulty < 2:
+                locations.remove(4)
+                locations.remove(5)
                 locations.remove(6)
 
             if self.options.dash_shuffle:

worlds/blasphemous/test/test_starting_locations.py

@@ -85,20 +85,7 @@ class TestGrievanceHard(BlasphemousTestBase):
     }
 
 
-class TestKnotOfWordsEasy(BlasphemousTestBase):
-    options = {
-        "starting_location": "knot_of_words",
-        "difficulty": "easy"
-    }
-
-
-class TestKnotOfWordsNormal(BlasphemousTestBase):
-    options = {
-        "starting_location": "knot_of_words",
-        "difficulty": "normal"
-    }
-
-
+# knot of the three words, rooftops, and mourning and havoc can't be selected on easy or normal. hard only
 class TestKnotOfWordsHard(BlasphemousTestBase):
     options = {
         "starting_location": "knot_of_words",
@@ -106,20 +93,6 @@ class TestKnotOfWordsHard(BlasphemousTestBase):
     }
 
 
-class TestRooftopsEasy(BlasphemousTestBase):
-    options = {
-        "starting_location": "rooftops",
-        "difficulty": "easy"
-    }
-
-
-class TestRooftopsNormal(BlasphemousTestBase):
-    options = {
-        "starting_location": "rooftops",
-        "difficulty": "normal"
-    }
-
-
 class TestRooftopsHard(BlasphemousTestBase):
     options = {
         "starting_location": "rooftops",
@@ -127,7 +100,6 @@ class TestRooftopsHard(BlasphemousTestBase):
     }
 
 
-# mourning and havoc can't be selected on easy or normal. hard only
 class TestMourningHavocHard(BlasphemousTestBase):
     options = {
         "starting_location": "mourning_havoc",

worlds/celeste64/CHANGELOG.md

@@ -1,6 +1,31 @@
 # Celeste 64 - Changelog
 
 
+## v1.3
+
+### Features:
+
+- New optional Location Checks
+	- Checkpointsanity
+- Hair Color
+	- Allows for setting of Maddy's hair color in each of No Dash, One Dash, Two Dash, and Feather states
+- Other Player Ghosts
+	- A game config option allows you to see ghosts of other Celeste 64 players in the multiworld
+
+### Quality of Life:
+
+- Checkpoint Warping
+	- Received Checkpoint items allow for warping to their respective checkpoint
+		- These items are on their respective checkpoint location if Checkpointsanity is disabled
+	- Logic accounts for being able to warp to otherwise inaccessible areas
+	- Checkpoints are a possible option for a starting item on Standard Logic + Move Shuffle + Checkpointsanity
+- New Options toggle to enable/disable background input
+
+### Bug Fixes:
+
+- Traffic Blocks now correctly appear disabled within Cassettes
+
+
 ## v1.2
 
 ### Features:

worlds/celeste64/Items.py

@@ -39,6 +39,22 @@ move_item_data_table: Dict[str, Celeste64ItemData] = {
     ItemName.climb:       Celeste64ItemData(celeste_64_base_id + 0xD, ItemClassification.progression),
 }
 
-item_data_table: Dict[str, Celeste64ItemData] = {**collectable_item_data_table, **unlockable_item_data_table, **move_item_data_table}
+checkpoint_item_data_table: Dict[str, Celeste64ItemData] = {
+    ItemName.checkpoint_1:  Celeste64ItemData(celeste_64_base_id + 0x20, ItemClassification.progression),
+    ItemName.checkpoint_2:  Celeste64ItemData(celeste_64_base_id + 0x21, ItemClassification.progression),
+    ItemName.checkpoint_3:  Celeste64ItemData(celeste_64_base_id + 0x22, ItemClassification.progression),
+    ItemName.checkpoint_4:  Celeste64ItemData(celeste_64_base_id + 0x23, ItemClassification.progression),
+    ItemName.checkpoint_5:  Celeste64ItemData(celeste_64_base_id + 0x24, ItemClassification.progression),
+    ItemName.checkpoint_6:  Celeste64ItemData(celeste_64_base_id + 0x25, ItemClassification.progression),
+    ItemName.checkpoint_7:  Celeste64ItemData(celeste_64_base_id + 0x26, ItemClassification.progression),
+    ItemName.checkpoint_8:  Celeste64ItemData(celeste_64_base_id + 0x27, ItemClassification.progression),
+    ItemName.checkpoint_9:  Celeste64ItemData(celeste_64_base_id + 0x28, ItemClassification.progression),
+    ItemName.checkpoint_10: Celeste64ItemData(celeste_64_base_id + 0x29, ItemClassification.progression),
+}
+
+item_data_table: Dict[str, Celeste64ItemData] = {**collectable_item_data_table,
+                                                 **unlockable_item_data_table,
+                                                 **move_item_data_table,
+                                                 **checkpoint_item_data_table}
 
 item_table = {name: data.code for name, data in item_data_table.items() if data.code is not None}

worlds/celeste64/Locations.py

@@ -1,7 +1,7 @@
 from typing import Dict, NamedTuple, Optional
 
 from BaseClasses import Location
-from .Names import LocationName
+from .Names import LocationName, RegionName
 
 
 celeste_64_base_id: int = 0xCA0000
@@ -17,66 +17,80 @@ class Celeste64LocationData(NamedTuple):
 
 
 strawberry_location_data_table: Dict[str, Celeste64LocationData] = {
-    LocationName.strawberry_1:  Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x00),
-    LocationName.strawberry_2:  Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x01),
-    LocationName.strawberry_3:  Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x02),
-    LocationName.strawberry_4:  Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x03),
-    LocationName.strawberry_5:  Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x04),
-    LocationName.strawberry_6:  Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x05),
-    LocationName.strawberry_7:  Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x06),
-    LocationName.strawberry_8:  Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x07),
-    LocationName.strawberry_9:  Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x08),
-    LocationName.strawberry_10: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x09),
-    LocationName.strawberry_11: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x0A),
-    LocationName.strawberry_12: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x0B),
-    LocationName.strawberry_13: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x0C),
-    LocationName.strawberry_14: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x0D),
-    LocationName.strawberry_15: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x0E),
-    LocationName.strawberry_16: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x0F),
-    LocationName.strawberry_17: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x10),
-    LocationName.strawberry_18: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x11),
-    LocationName.strawberry_19: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x12),
-    LocationName.strawberry_20: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x13),
-    LocationName.strawberry_21: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x14),
-    LocationName.strawberry_22: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x15),
-    LocationName.strawberry_23: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x16),
-    LocationName.strawberry_24: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x17),
-    LocationName.strawberry_25: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x18),
-    LocationName.strawberry_26: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x19),
-    LocationName.strawberry_27: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x1A),
-    LocationName.strawberry_28: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x1B),
-    LocationName.strawberry_29: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x1C),
-    LocationName.strawberry_30: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x1D),
+    LocationName.strawberry_1:  Celeste64LocationData(RegionName.intro_islands,        celeste_64_base_id + 0x00),
+    LocationName.strawberry_2:  Celeste64LocationData(RegionName.granny_island,        celeste_64_base_id + 0x01),
+    LocationName.strawberry_3:  Celeste64LocationData(RegionName.granny_island,        celeste_64_base_id + 0x02),
+    LocationName.strawberry_4:  Celeste64LocationData(RegionName.granny_island,        celeste_64_base_id + 0x03),
+    LocationName.strawberry_5:  Celeste64LocationData(RegionName.granny_island,        celeste_64_base_id + 0x04),
+    LocationName.strawberry_6:  Celeste64LocationData(RegionName.highway_island,       celeste_64_base_id + 0x05),
+    LocationName.strawberry_7:  Celeste64LocationData(RegionName.highway_island,       celeste_64_base_id + 0x06),
+    LocationName.strawberry_8:  Celeste64LocationData(RegionName.nw_girders_island,    celeste_64_base_id + 0x07),
+    LocationName.strawberry_9:  Celeste64LocationData(RegionName.granny_island,        celeste_64_base_id + 0x08),
+    LocationName.strawberry_10: Celeste64LocationData(RegionName.granny_island,        celeste_64_base_id + 0x09),
+    LocationName.strawberry_11: Celeste64LocationData(RegionName.granny_island,        celeste_64_base_id + 0x0A),
+    LocationName.strawberry_12: Celeste64LocationData(RegionName.badeline_tower_lower, celeste_64_base_id + 0x0B),
+    LocationName.strawberry_13: Celeste64LocationData(RegionName.highway_island,       celeste_64_base_id + 0x0C),
+    LocationName.strawberry_14: Celeste64LocationData(RegionName.ne_feathers_island,   celeste_64_base_id + 0x0D),
+    LocationName.strawberry_15: Celeste64LocationData(RegionName.ne_feathers_island,   celeste_64_base_id + 0x0E),
+    LocationName.strawberry_16: Celeste64LocationData(RegionName.ne_feathers_island,   celeste_64_base_id + 0x0F),
+    LocationName.strawberry_17: Celeste64LocationData(RegionName.se_house_island,      celeste_64_base_id + 0x10),
+    LocationName.strawberry_18: Celeste64LocationData(RegionName.se_house_island,      celeste_64_base_id + 0x11),
+    LocationName.strawberry_19: Celeste64LocationData(RegionName.se_house_island,      celeste_64_base_id + 0x12),
+    LocationName.strawberry_20: Celeste64LocationData(RegionName.badeline_tower_lower, celeste_64_base_id + 0x13),
+    LocationName.strawberry_21: Celeste64LocationData(RegionName.granny_island,        celeste_64_base_id + 0x14),
+    LocationName.strawberry_22: Celeste64LocationData(RegionName.granny_island,        celeste_64_base_id + 0x15),
+    LocationName.strawberry_23: Celeste64LocationData(RegionName.highway_island,       celeste_64_base_id + 0x16),
+    LocationName.strawberry_24: Celeste64LocationData(RegionName.granny_island,        celeste_64_base_id + 0x17),
+    LocationName.strawberry_25: Celeste64LocationData(RegionName.se_house_island,      celeste_64_base_id + 0x18),
+    LocationName.strawberry_26: Celeste64LocationData(RegionName.highway_island,       celeste_64_base_id + 0x19),
+    LocationName.strawberry_27: Celeste64LocationData(RegionName.ne_feathers_island,   celeste_64_base_id + 0x1A),
+    LocationName.strawberry_28: Celeste64LocationData(RegionName.ne_feathers_island,   celeste_64_base_id + 0x1B),
+    LocationName.strawberry_29: Celeste64LocationData(RegionName.badeline_tower_upper, celeste_64_base_id + 0x1C),
+    LocationName.strawberry_30: Celeste64LocationData(RegionName.badeline_island,      celeste_64_base_id + 0x1D),
 }
 
 friend_location_data_table: Dict[str, Celeste64LocationData] = {
-    LocationName.granny_1:   Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x100 + 0x00),
-    LocationName.granny_2:   Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x100 + 0x01),
-    LocationName.granny_3:   Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x100 + 0x02),
-    LocationName.theo_1:     Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x100 + 0x03),
-    LocationName.theo_2:     Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x100 + 0x04),
-    LocationName.theo_3:     Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x100 + 0x05),
-    LocationName.badeline_1: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x100 + 0x06),
-    LocationName.badeline_2: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x100 + 0x07),
-    LocationName.badeline_3: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x100 + 0x08),
+    LocationName.granny_1:   Celeste64LocationData(RegionName.granny_island,   celeste_64_base_id + 0x100 + 0x00),
+    LocationName.granny_2:   Celeste64LocationData(RegionName.granny_island,   celeste_64_base_id + 0x100 + 0x01),
+    LocationName.granny_3:   Celeste64LocationData(RegionName.granny_island,   celeste_64_base_id + 0x100 + 0x02),
+    LocationName.theo_1:     Celeste64LocationData(RegionName.granny_island,   celeste_64_base_id + 0x100 + 0x03),
+    LocationName.theo_2:     Celeste64LocationData(RegionName.granny_island,   celeste_64_base_id + 0x100 + 0x04),
+    LocationName.theo_3:     Celeste64LocationData(RegionName.granny_island,   celeste_64_base_id + 0x100 + 0x05),
+    LocationName.badeline_1: Celeste64LocationData(RegionName.badeline_island, celeste_64_base_id + 0x100 + 0x06),
+    LocationName.badeline_2: Celeste64LocationData(RegionName.badeline_island, celeste_64_base_id + 0x100 + 0x07),
+    LocationName.badeline_3: Celeste64LocationData(RegionName.badeline_island, celeste_64_base_id + 0x100 + 0x08),
 }
 
 sign_location_data_table: Dict[str, Celeste64LocationData] = {
-    LocationName.sign_1: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x200 + 0x00),
-    LocationName.sign_2: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x200 + 0x01),
-    LocationName.sign_3: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x200 + 0x02),
-    LocationName.sign_4: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x200 + 0x03),
-    LocationName.sign_5: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x200 + 0x04),
+    LocationName.sign_1: Celeste64LocationData(RegionName.granny_island,   celeste_64_base_id + 0x200 + 0x00),
+    LocationName.sign_2: Celeste64LocationData(RegionName.granny_island,   celeste_64_base_id + 0x200 + 0x01),
+    LocationName.sign_3: Celeste64LocationData(RegionName.highway_island,  celeste_64_base_id + 0x200 + 0x02),
+    LocationName.sign_4: Celeste64LocationData(RegionName.se_house_island, celeste_64_base_id + 0x200 + 0x03),
+    LocationName.sign_5: Celeste64LocationData(RegionName.badeline_island, celeste_64_base_id + 0x200 + 0x04),
 }
 
 car_location_data_table: Dict[str, Celeste64LocationData] = {
-    LocationName.car_1: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x300 + 0x00),
-    LocationName.car_2: Celeste64LocationData("Forsaken City", celeste_64_base_id + 0x300 + 0x01),
+    LocationName.car_1: Celeste64LocationData(RegionName.intro_islands, celeste_64_base_id + 0x300 + 0x00),
+    LocationName.car_2: Celeste64LocationData(RegionName.granny_island, celeste_64_base_id + 0x300 + 0x01),
+}
+
+checkpoint_location_data_table: Dict[str, Celeste64LocationData] = {
+    LocationName.checkpoint_1:  Celeste64LocationData(RegionName.intro_islands,        celeste_64_base_id + 0x400 + 0x00),
+    LocationName.checkpoint_2:  Celeste64LocationData(RegionName.granny_island,        celeste_64_base_id + 0x400 + 0x01),
+    LocationName.checkpoint_3:  Celeste64LocationData(RegionName.granny_island,        celeste_64_base_id + 0x400 + 0x02),
+    LocationName.checkpoint_4:  Celeste64LocationData(RegionName.granny_island,        celeste_64_base_id + 0x400 + 0x03),
+    LocationName.checkpoint_5:  Celeste64LocationData(RegionName.highway_island,       celeste_64_base_id + 0x400 + 0x04),
+    LocationName.checkpoint_6:  Celeste64LocationData(RegionName.highway_island,       celeste_64_base_id + 0x400 + 0x05),
+    LocationName.checkpoint_7:  Celeste64LocationData(RegionName.ne_feathers_island,   celeste_64_base_id + 0x400 + 0x06),
+    LocationName.checkpoint_8:  Celeste64LocationData(RegionName.se_house_island,      celeste_64_base_id + 0x400 + 0x07),
+    LocationName.checkpoint_9:  Celeste64LocationData(RegionName.badeline_tower_upper, celeste_64_base_id + 0x400 + 0x08),
+    LocationName.checkpoint_10: Celeste64LocationData(RegionName.badeline_island,      celeste_64_base_id + 0x400 + 0x09),
 }
 
 location_data_table: Dict[str, Celeste64LocationData] = {**strawberry_location_data_table,
                                                          **friend_location_data_table,
                                                          **sign_location_data_table,
-                                                         **car_location_data_table}
+                                                         **car_location_data_table,
+                                                         **checkpoint_location_data_table}
 
 location_table = {name: data.address for name, data in location_data_table.items() if data.address is not None}

worlds/celeste64/Names/ItemName.py

@@ -15,3 +15,18 @@ ground_dash = "Ground Dash"
 air_dash    = "Air Dash"
 skid_jump   = "Skid Jump"
 climb       = "Climb"
+
+# Checkpoint Items
+checkpoint_1  = "Intro Checkpoint"
+checkpoint_2  = "Granny Checkpoint"
+checkpoint_3  = "South-East Tower Checkpoint"
+checkpoint_4  = "Climb Sign Checkpoint"
+checkpoint_5  = "Freeway Checkpoint"
+checkpoint_6  = "Freeway Feather Checkpoint"
+checkpoint_7  = "Feather Maze Checkpoint"
+checkpoint_8  = "Double Dash House Checkpoint"
+checkpoint_9  = "Badeline Tower Checkpoint"
+checkpoint_10 = "Badeline Island Checkpoint"
+
+# Item used for logic definitions that are not possible with the given options
+cannot_access = "CANNOT ACCESS"

worlds/celeste64/Names/LocationName.py

@@ -10,7 +10,7 @@ strawberry_8  = "Traffic Block Strawberry"
 strawberry_9  = "South-West Dash Refills Strawberry"
 strawberry_10 = "South-East Tower Side Strawberry"
 strawberry_11 = "Girders Strawberry"
-strawberry_12 = "North-East Tower Bottom Strawberry"
+strawberry_12 = "Badeline Tower Bottom Strawberry"
 strawberry_13 = "Breakable Blocks Strawberry"
 strawberry_14 = "Feather Maze Strawberry"
 strawberry_15 = "Feather Chain Strawberry"
@@ -18,7 +18,7 @@ strawberry_16 = "Feather Hidden Strawberry"
 strawberry_17 = "Double Dash Puzzle Strawberry"
 strawberry_18 = "Double Dash Spike Climb Strawberry"
 strawberry_19 = "Double Dash Spring Strawberry"
-strawberry_20 = "North-East Tower Breakable Bottom Strawberry"
+strawberry_20 = "Badeline Tower Breakable Bottom Strawberry"
 strawberry_21 = "Theo Tower Lower Cassette Strawberry"
 strawberry_22 = "Theo Tower Upper Cassette Strawberry"
 strawberry_23 = "South End of Bridge Cassette Strawberry"
@@ -27,8 +27,8 @@ strawberry_25 = "Cassette Hidden in the House Strawberry"
 strawberry_26 = "North End of Bridge Cassette Strawberry"
 strawberry_27 = "Distant Feather Cassette Strawberry"
 strawberry_28 = "Feather Arches Cassette Strawberry"
-strawberry_29 = "North-East Tower Cassette Strawberry"
-strawberry_30 = "Badeline Cassette Strawberry"
+strawberry_29 = "Badeline Tower Cassette Strawberry"
+strawberry_30 = "Badeline Island Cassette Strawberry"
 
 # Friend Locations
 granny_1   = "Granny Conversation 1"
@@ -51,3 +51,15 @@ sign_5 = "Credits Sign"
 # Car Locations
 car_1 = "Intro Car"
 car_2 = "Secret Car"
+
+# Checkpoint Locations
+checkpoint_1  = "Intro Checkpoint"
+checkpoint_2  = "Granny Checkpoint"
+checkpoint_3  = "South-East Tower Checkpoint"
+checkpoint_4  = "Climb Sign Checkpoint"
+checkpoint_5  = "Freeway Checkpoint"
+checkpoint_6  = "Freeway Feather Checkpoint"
+checkpoint_7  = "Feather Maze Checkpoint"
+checkpoint_8  = "Double Dash House Checkpoint"
+checkpoint_9  = "Badeline Tower Checkpoint"
+checkpoint_10 = "Badeline Island Checkpoint"

worlds/celeste64/Names/RegionName.py

@@ -0,0 +1,13 @@
+# Level Base Regions
+forsaken_city = "Forsaken City"
+
+# Forsaken City Regions
+intro_islands        = "Intro Islands"
+granny_island        = "Granny Island"
+highway_island       = "Freeway Island"
+nw_girders_island    = "North-West Girders Island"
+ne_feathers_island   = "North-East Feathers Island"
+se_house_island      = "South-East House Island"
+badeline_tower_lower = "Badeline Tower Lower"
+badeline_tower_upper = "Badeline Tower Upper"
+badeline_island      = "Badeline Island"

worlds/celeste64/Options.py

@@ -1,6 +1,8 @@
 from dataclasses import dataclass
+import random
 
-from Options import Choice, Range, Toggle, DeathLink, OptionGroup, PerGameCommonOptions
+from Options import Choice, TextChoice, Range, Toggle, DeathLink, OptionGroup, PerGameCommonOptions, OptionError
+from worlds.AutoWorld import World
 
 
 class DeathLinkAmnesty(Range):
@@ -18,7 +20,7 @@ class TotalStrawberries(Range):
     """
     display_name = "Total Strawberries"
     range_start = 0
-    range_end = 46
+    range_end = 55
     default = 20
 
 class StrawberriesRequiredPercentage(Range):
@@ -73,6 +75,93 @@ class Carsanity(Toggle):
     """
     display_name = "Carsanity"
 
+class Checkpointsanity(Toggle):
+    """
+    Whether activating Checkpoints grants location checks
+
+    Activating this will also shuffle items into the pool which allow usage and warping to each Checkpoint
+    """
+    display_name = "Checkpointsanity"
+
+
+class ColorChoice(TextChoice):
+    option_strawberry = 0xDB2C00
+    option_empty = 0x6EC0FF
+    option_double = 0xFA91FF
+    option_golden = 0xF2D450
+    option_baddy = 0x9B3FB5
+    option_fire_red = 0xFF0000
+    option_maroon = 0x800000
+    option_salmon = 0xFF3A65
+    option_orange = 0xD86E0A
+    option_lime_green = 0x8DF920
+    option_bright_green = 0x0DAF05
+    option_forest_green = 0x132818
+    option_royal_blue = 0x0036BF
+    option_brown = 0xB78726
+    option_black = 0x000000
+    option_white = 0xFFFFFF
+    option_grey = 0x808080
+    option_any_color = -1
+
+    @classmethod
+    def from_text(cls, text: str) -> Choice:
+        text = text.lower()
+        if text == "random":
+            choice_list = list(cls.name_lookup)
+            choice_list.remove(cls.option_any_color)
+            return cls(random.choice(choice_list))
+        return super().from_text(text)
+
+
+class MadelineOneDashHairColor(ColorChoice):
+    """
+    What color Madeline's hair is when she has one dash
+
+    The `any_color` option will choose a fully random color
+
+    A custom color entry may be supplied as a 6-character RGB hex color code
+    e.g. F542C8
+    """
+    display_name = "Madeline One Dash Hair Color"
+    default = ColorChoice.option_strawberry
+
+class MadelineTwoDashHairColor(ColorChoice):
+    """
+    What color Madeline's hair is when she has two dashes
+
+    The `any_color` option will choose a fully random color
+
+    A custom color entry may be supplied as a 6-character RGB hex color code
+    e.g. F542C8
+    """
+    display_name = "Madeline Two Dash Hair Color"
+    default = ColorChoice.option_double
+
+class MadelineNoDashHairColor(ColorChoice):
+    """
+    What color Madeline's hair is when she has no dashes
+
+    The `any_color` option will choose a fully random color
+
+    A custom color entry may be supplied as a 6-character RGB hex color code
+    e.g. F542C8
+    """
+    display_name = "Madeline No Dash Hair Color"
+    default = ColorChoice.option_empty
+
+class MadelineFeatherHairColor(ColorChoice):
+    """
+    What color Madeline's hair is when she has a feather
+
+    The `any_color` option will choose a fully random color
+
+    A custom color entry may be supplied as a 6-character RGB hex color code
+    e.g. F542C8
+    """
+    display_name = "Madeline Feather Hair Color"
+    default = ColorChoice.option_golden
+
 
 class BadelineChaserSource(Choice):
     """
@@ -119,6 +208,13 @@ celeste_64_option_groups = [
         Friendsanity,
         Signsanity,
         Carsanity,
+        Checkpointsanity,
+    ]),
+    OptionGroup("Aesthetic Options", [
+        MadelineOneDashHairColor,
+        MadelineTwoDashHairColor,
+        MadelineNoDashHairColor,
+        MadelineFeatherHairColor,
     ]),
     OptionGroup("Badeline Chasers", [
         BadelineChaserSource,
@@ -142,7 +238,68 @@ class Celeste64Options(PerGameCommonOptions):
     friendsanity: Friendsanity
     signsanity: Signsanity
     carsanity: Carsanity
+    checkpointsanity: Checkpointsanity
+
+    madeline_one_dash_hair_color: MadelineOneDashHairColor
+    madeline_two_dash_hair_color: MadelineTwoDashHairColor
+    madeline_no_dash_hair_color: MadelineNoDashHairColor
+    madeline_feather_hair_color: MadelineFeatherHairColor
 
     badeline_chaser_source: BadelineChaserSource
     badeline_chaser_frequency: BadelineChaserFrequency
     badeline_chaser_speed: BadelineChaserSpeed
+
+
+def resolve_options(world: World):
+    # One Dash Hair
+    if isinstance(world.options.madeline_one_dash_hair_color.value, str):
+        try:
+            world.madeline_one_dash_hair_color = int(world.options.madeline_one_dash_hair_color.value.strip("#")[:6], 16)
+        except ValueError:
+            raise OptionError(f"Invalid input for option `madeline_one_dash_hair_color`:"
+                              f"{world.options.madeline_one_dash_hair_color.value} for "
+                              f"{world.player_name}")
+    elif world.options.madeline_one_dash_hair_color.value == ColorChoice.option_any_color:
+        world.madeline_one_dash_hair_color = world.random.randint(0, 0xFFFFFF)
+    else:
+        world.madeline_one_dash_hair_color = world.options.madeline_one_dash_hair_color.value
+
+    # Two Dash Hair
+    if isinstance(world.options.madeline_two_dash_hair_color.value, str):
+        try:
+            world.madeline_two_dash_hair_color = int(world.options.madeline_two_dash_hair_color.value.strip("#")[:6], 16)
+        except ValueError:
+            raise OptionError(f"Invalid input for option `madeline_two_dash_hair_color`:"
+                              f"{world.options.madeline_two_dash_hair_color.value} for "
+                              f"{world.player_name}")
+    elif world.options.madeline_two_dash_hair_color.value == ColorChoice.option_any_color:
+        world.madeline_two_dash_hair_color = world.random.randint(0, 0xFFFFFF)
+    else:
+        world.madeline_two_dash_hair_color = world.options.madeline_two_dash_hair_color.value
+
+    # No Dash Hair
+    if isinstance(world.options.madeline_no_dash_hair_color.value, str):
+        try:
+            world.madeline_no_dash_hair_color = int(world.options.madeline_no_dash_hair_color.value.strip("#")[:6], 16)
+        except ValueError:
+            raise OptionError(f"Invalid input for option `madeline_no_dash_hair_color`:"
+                              f"{world.options.madeline_no_dash_hair_color.value} for "
+                              f"{world.player_name}")
+    elif world.options.madeline_no_dash_hair_color.value == ColorChoice.option_any_color:
+        world.madeline_no_dash_hair_color = world.random.randint(0, 0xFFFFFF)
+    else:
+        world.madeline_no_dash_hair_color = world.options.madeline_no_dash_hair_color.value
+
+    # Feather Hair
+    if isinstance(world.options.madeline_feather_hair_color.value, str):
+        try:
+            world.madeline_feather_hair_color = int(world.options.madeline_feather_hair_color.value.strip("#")[:6], 16)
+        except ValueError:
+            raise OptionError(f"Invalid input for option `madeline_feather_hair_color`:"
+                              f"{world.options.madeline_feather_hair_color.value} for "
+                              f"{world.player_name}")
+    elif world.options.madeline_feather_hair_color.value == ColorChoice.option_any_color:
+        world.madeline_feather_hair_color = world.random.randint(0, 0xFFFFFF)
+    else:
+        world.madeline_feather_hair_color = world.options.madeline_feather_hair_color.value
+

worlds/celeste64/Regions.py

@@ -1,11 +1,23 @@
 from typing import Dict, List, NamedTuple
 
+from .Names import RegionName
 
 class Celeste64RegionData(NamedTuple):
     connecting_regions: List[str] = []
 
 
 region_data_table: Dict[str, Celeste64RegionData] = {
-    "Menu": Celeste64RegionData(["Forsaken City"]),
-    "Forsaken City": Celeste64RegionData(),
+    "Menu": Celeste64RegionData([RegionName.forsaken_city]),
+
+    RegionName.forsaken_city: Celeste64RegionData([RegionName.intro_islands, RegionName.granny_island, RegionName.highway_island, RegionName.ne_feathers_island, RegionName.se_house_island, RegionName.badeline_tower_upper, RegionName.badeline_island]),
+
+    RegionName.intro_islands:        Celeste64RegionData([RegionName.granny_island]),
+    RegionName.granny_island:        Celeste64RegionData([RegionName.highway_island, RegionName.nw_girders_island, RegionName.badeline_tower_lower, RegionName.se_house_island]),
+    RegionName.highway_island:       Celeste64RegionData([RegionName.granny_island, RegionName.ne_feathers_island, RegionName.nw_girders_island]),
+    RegionName.nw_girders_island:    Celeste64RegionData([RegionName.highway_island]),
+    RegionName.ne_feathers_island:   Celeste64RegionData([RegionName.se_house_island, RegionName.highway_island, RegionName.badeline_tower_lower, RegionName.badeline_tower_upper]),
+    RegionName.se_house_island:      Celeste64RegionData([RegionName.ne_feathers_island, RegionName.granny_island, RegionName.badeline_tower_lower]),
+    RegionName.badeline_tower_lower: Celeste64RegionData([RegionName.se_house_island, RegionName.ne_feathers_island, RegionName.granny_island, RegionName.badeline_tower_upper]),
+    RegionName.badeline_tower_upper: Celeste64RegionData([RegionName.badeline_island, RegionName.badeline_tower_lower, RegionName.se_house_island, RegionName.ne_feathers_island, RegionName.granny_island]),
+    RegionName.badeline_island:      Celeste64RegionData([RegionName.badeline_tower_upper, RegionName.granny_island, RegionName.highway_island]),
 }

worlds/celeste64/Rules.py

@@ -1,265 +1,85 @@
-from typing import Dict, List
+from typing import Dict, List, Tuple, Callable
 
-from BaseClasses import CollectionState
+from BaseClasses import CollectionState, Region
 from worlds.generic.Rules import set_rule
 
 from . import Celeste64World
-from .Names import ItemName, LocationName
+from .Names import ItemName, LocationName, RegionName
 
 
 def set_rules(world: Celeste64World):
     if world.options.logic_difficulty == "standard":
-        if world.options.move_shuffle:
-            world.active_logic_mapping = location_standard_moves_logic
-        else:
-            world.active_logic_mapping = location_standard_logic
+        world.active_logic_mapping = location_standard_moves_logic
+        world.active_region_logic_mapping = region_standard_moves_logic
     else:
-        if world.options.move_shuffle:
-            world.active_logic_mapping = location_hard_moves_logic
-        else:
-            world.active_logic_mapping = location_hard_logic
+        world.active_logic_mapping = location_hard_moves_logic
+        world.active_region_logic_mapping = region_hard_moves_logic
 
     for location in world.multiworld.get_locations(world.player):
         set_rule(location, lambda state, location=location: location_rule(state, world, location.name))
 
-    if world.options.logic_difficulty == "standard":
-        if world.options.move_shuffle:
-            world.goal_logic_mapping = goal_standard_moves_logic
-        else:
-            world.goal_logic_mapping = goal_standard_logic
-    else:
-        if world.options.move_shuffle:
-            world.goal_logic_mapping = goal_hard_moves_logic
-        else:
-            world.goal_logic_mapping = goal_hard_logic
-
     # Completion condition.
     world.multiworld.completion_condition[world.player] = lambda state: goal_rule(state, world)
 
 
-goal_standard_logic: List[List[str]] = [[ItemName.feather, ItemName.traffic_block, ItemName.breakables, ItemName.double_dash_refill]]
-goal_hard_logic: List[List[str]] = [[]]
-goal_standard_moves_logic: List[List[str]] = [[ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.breakables, ItemName.air_dash, ItemName.climb]]
-goal_hard_moves_logic: List[List[str]] = [[ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.breakables, ItemName.air_dash, ItemName.climb],
-                                          [ItemName.traffic_block, ItemName.air_dash, ItemName.skid_jump],
-                                          [ItemName.ground_dash, ItemName.air_dash, ItemName.skid_jump],
-                                          [ItemName.feather, ItemName.traffic_block, ItemName.air_dash],
-                                          [ItemName.traffic_block, ItemName.ground_dash, ItemName.air_dash]]
-
-
-location_standard_logic: Dict[str, List[List[str]]] = {
-    LocationName.strawberry_4:  [[ItemName.traffic_block, ItemName.breakables]],
-    LocationName.strawberry_6:  [[ItemName.dash_refill],
-                                 [ItemName.traffic_block]],
-    LocationName.strawberry_7:  [[ItemName.dash_refill],
-                                 [ItemName.traffic_block]],
-    LocationName.strawberry_8:  [[ItemName.traffic_block]],
-    LocationName.strawberry_9:  [[ItemName.dash_refill]],
-    LocationName.strawberry_11: [[ItemName.dash_refill],
-                                 [ItemName.traffic_block]],
-    LocationName.strawberry_12: [[ItemName.dash_refill, ItemName.double_dash_refill],
-                                 [ItemName.traffic_block, ItemName.double_dash_refill]],
-    LocationName.strawberry_13: [[ItemName.dash_refill, ItemName.breakables],
-                                 [ItemName.traffic_block, ItemName.breakables]],
-    LocationName.strawberry_14: [[ItemName.dash_refill, ItemName.feather],
-                                 [ItemName.traffic_block, ItemName.feather]],
-    LocationName.strawberry_15: [[ItemName.dash_refill, ItemName.feather],
-                                 [ItemName.traffic_block, ItemName.feather]],
-    LocationName.strawberry_16: [[ItemName.dash_refill, ItemName.feather],
-                                 [ItemName.traffic_block, ItemName.feather]],
-    LocationName.strawberry_17: [[ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block]],
-    LocationName.strawberry_18: [[ItemName.dash_refill, ItemName.double_dash_refill],
-                                 [ItemName.traffic_block, ItemName.feather, ItemName.double_dash_refill]],
-    LocationName.strawberry_19: [[ItemName.dash_refill, ItemName.double_dash_refill, ItemName.spring],
-                                 [ItemName.traffic_block, ItemName.double_dash_refill, ItemName.feather, ItemName.spring]],
-    LocationName.strawberry_20: [[ItemName.dash_refill, ItemName.feather, ItemName.breakables],
-                                 [ItemName.traffic_block, ItemName.feather, ItemName.breakables]],
-
-    LocationName.strawberry_21: [[ItemName.cassette, ItemName.traffic_block, ItemName.breakables]],
-    LocationName.strawberry_22: [[ItemName.cassette, ItemName.dash_refill, ItemName.breakables]],
-    LocationName.strawberry_23: [[ItemName.cassette, ItemName.dash_refill, ItemName.coin],
-                                 [ItemName.cassette, ItemName.traffic_block, ItemName.coin]],
-    LocationName.strawberry_24: [[ItemName.cassette, ItemName.dash_refill, ItemName.traffic_block]],
-    LocationName.strawberry_25: [[ItemName.cassette, ItemName.dash_refill, ItemName.double_dash_refill],
-                                 [ItemName.cassette, ItemName.traffic_block, ItemName.feather, ItemName.double_dash_refill]],
-    LocationName.strawberry_26: [[ItemName.cassette, ItemName.dash_refill],
-                                 [ItemName.cassette, ItemName.traffic_block]],
-    LocationName.strawberry_27: [[ItemName.cassette, ItemName.dash_refill, ItemName.feather, ItemName.coin],
-                                 [ItemName.cassette, ItemName.traffic_block, ItemName.feather, ItemName.coin]],
-    LocationName.strawberry_28: [[ItemName.cassette, ItemName.dash_refill, ItemName.feather, ItemName.coin],
-                                 [ItemName.cassette, ItemName.traffic_block, ItemName.feather, ItemName.coin]],
-    LocationName.strawberry_29: [[ItemName.cassette, ItemName.dash_refill, ItemName.feather, ItemName.coin]],
-    LocationName.strawberry_30: [[ItemName.cassette, ItemName.dash_refill, ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.spring, ItemName.breakables]],
-
-    LocationName.theo_1:     [[ItemName.traffic_block, ItemName.breakables]],
-    LocationName.theo_2:     [[ItemName.traffic_block, ItemName.breakables]],
-    LocationName.theo_3:     [[ItemName.traffic_block, ItemName.breakables]],
-    LocationName.badeline_1: [[ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.breakables]],
-    LocationName.badeline_2: [[ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.breakables]],
-    LocationName.badeline_3: [[ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.breakables]],
-
-    LocationName.sign_2: [[ItemName.breakables]],
-    LocationName.sign_3: [[ItemName.dash_refill],
-                          [ItemName.traffic_block]],
-    LocationName.sign_4: [[ItemName.dash_refill, ItemName.double_dash_refill],
-                          [ItemName.dash_refill, ItemName.feather],
-                          [ItemName.traffic_block, ItemName.feather]],
-    LocationName.sign_5: [[ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.breakables]],
-
-    LocationName.car_2: [[ItemName.breakables]],
-}
-
-location_hard_logic: Dict[str, List[List[str]]] = {
-    LocationName.strawberry_13: [[ItemName.breakables]],
-    LocationName.strawberry_17: [[ItemName.double_dash_refill, ItemName.traffic_block]],
-    LocationName.strawberry_20: [[ItemName.breakables]],
-
-    LocationName.strawberry_21: [[ItemName.cassette, ItemName.traffic_block, ItemName.breakables]],
-    LocationName.strawberry_22: [[ItemName.cassette]],
-    LocationName.strawberry_23: [[ItemName.cassette, ItemName.coin]],
-    LocationName.strawberry_24: [[ItemName.cassette]],
-    LocationName.strawberry_25: [[ItemName.cassette, ItemName.double_dash_refill]],
-    LocationName.strawberry_26: [[ItemName.cassette]],
-    LocationName.strawberry_27: [[ItemName.cassette]],
-    LocationName.strawberry_28: [[ItemName.cassette, ItemName.feather]],
-    LocationName.strawberry_29: [[ItemName.cassette]],
-    LocationName.strawberry_30: [[ItemName.cassette, ItemName.dash_refill, ItemName.double_dash_refill, ItemName.traffic_block, ItemName.breakables]],
-
-    LocationName.sign_2: [[ItemName.breakables]],
-
-    LocationName.car_2: [[ItemName.breakables]],
-}
-
 location_standard_moves_logic: Dict[str, List[List[str]]] = {
     LocationName.strawberry_1:  [[ItemName.ground_dash],
                                  [ItemName.air_dash],
-                                 [ItemName.skid_jump],
-                                 [ItemName.climb]],
-    LocationName.strawberry_2:  [[ItemName.ground_dash],
-                                 [ItemName.air_dash],
-                                 [ItemName.skid_jump],
                                  [ItemName.climb]],
+    LocationName.strawberry_2:  [[ItemName.air_dash],
+                                 [ItemName.skid_jump]],
     LocationName.strawberry_3:  [[ItemName.air_dash],
                                  [ItemName.skid_jump]],
     LocationName.strawberry_4:  [[ItemName.traffic_block, ItemName.breakables, ItemName.air_dash]],
     LocationName.strawberry_5:  [[ItemName.air_dash]],
-    LocationName.strawberry_6:  [[ItemName.dash_refill, ItemName.air_dash],
-                                 [ItemName.traffic_block, ItemName.ground_dash],
-                                 [ItemName.traffic_block, ItemName.air_dash],
-                                 [ItemName.traffic_block, ItemName.skid_jump],
-                                 [ItemName.traffic_block, ItemName.climb]],
-    LocationName.strawberry_7:  [[ItemName.dash_refill, ItemName.air_dash],
-                                 [ItemName.traffic_block, ItemName.ground_dash],
-                                 [ItemName.traffic_block, ItemName.air_dash],
-                                 [ItemName.traffic_block, ItemName.skid_jump],
-                                 [ItemName.traffic_block, ItemName.climb]],
-    LocationName.strawberry_8:  [[ItemName.traffic_block, ItemName.ground_dash],
-                                 [ItemName.traffic_block, ItemName.air_dash],
-                                 [ItemName.traffic_block, ItemName.skid_jump],
-                                 [ItemName.traffic_block, ItemName.climb]],
     LocationName.strawberry_9:  [[ItemName.dash_refill, ItemName.air_dash]],
     LocationName.strawberry_10: [[ItemName.climb]],
-    LocationName.strawberry_11: [[ItemName.dash_refill, ItemName.air_dash, ItemName.climb],
-                                 [ItemName.traffic_block, ItemName.climb]],
-    LocationName.strawberry_12: [[ItemName.dash_refill, ItemName.double_dash_refill, ItemName.air_dash],
-                                 [ItemName.traffic_block, ItemName.double_dash_refill, ItemName.air_dash]],
-    LocationName.strawberry_13: [[ItemName.dash_refill, ItemName.breakables, ItemName.air_dash],
-                                 [ItemName.traffic_block, ItemName.breakables, ItemName.ground_dash],
-                                 [ItemName.traffic_block, ItemName.breakables, ItemName.air_dash]],
-    LocationName.strawberry_14: [[ItemName.dash_refill, ItemName.feather, ItemName.air_dash],
-                                 [ItemName.traffic_block, ItemName.feather, ItemName.air_dash]],
-    LocationName.strawberry_15: [[ItemName.dash_refill, ItemName.feather, ItemName.air_dash, ItemName.climb],
-                                 [ItemName.traffic_block, ItemName.feather, ItemName.climb]],
-    LocationName.strawberry_16: [[ItemName.dash_refill, ItemName.feather, ItemName.air_dash],
-                                 [ItemName.traffic_block, ItemName.feather]],
-    LocationName.strawberry_17: [[ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.ground_dash],
-                                 [ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.air_dash],
-                                 [ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.skid_jump],
-                                 [ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.climb]],
-    LocationName.strawberry_18: [[ItemName.dash_refill, ItemName.double_dash_refill, ItemName.air_dash, ItemName.climb],
-                                 [ItemName.traffic_block, ItemName.feather, ItemName.double_dash_refill, ItemName.air_dash, ItemName.climb]],
-    LocationName.strawberry_19: [[ItemName.dash_refill, ItemName.double_dash_refill, ItemName.spring, ItemName.air_dash],
-                                 [ItemName.traffic_block, ItemName.double_dash_refill, ItemName.feather, ItemName.spring, ItemName.air_dash]],
-    LocationName.strawberry_20: [[ItemName.dash_refill, ItemName.feather, ItemName.breakables, ItemName.air_dash],
-                                 [ItemName.traffic_block, ItemName.feather, ItemName.breakables, ItemName.air_dash]],
+    LocationName.strawberry_11: [[ItemName.air_dash, ItemName.climb]],
+    LocationName.strawberry_13: [[ItemName.breakables, ItemName.air_dash],
+                                 [ItemName.breakables, ItemName.ground_dash]],
+    LocationName.strawberry_14: [[ItemName.feather, ItemName.air_dash]],
+    LocationName.strawberry_15: [[ItemName.feather, ItemName.air_dash, ItemName.climb]],
+    LocationName.strawberry_16: [[ItemName.feather]],
+    LocationName.strawberry_17: [[ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block]],
+    LocationName.strawberry_18: [[ItemName.double_dash_refill, ItemName.air_dash, ItemName.climb]],
+    LocationName.strawberry_19: [[ItemName.double_dash_refill, ItemName.spring, ItemName.air_dash, ItemName.skid_jump]],
+    LocationName.strawberry_20: [[ItemName.feather, ItemName.breakables, ItemName.air_dash]],
 
     LocationName.strawberry_21: [[ItemName.cassette, ItemName.traffic_block, ItemName.breakables, ItemName.air_dash]],
     LocationName.strawberry_22: [[ItemName.cassette, ItemName.dash_refill, ItemName.breakables, ItemName.air_dash]],
-    LocationName.strawberry_23: [[ItemName.cassette, ItemName.dash_refill, ItemName.coin, ItemName.air_dash, ItemName.climb],
-                                 [ItemName.cassette, ItemName.traffic_block, ItemName.coin, ItemName.air_dash, ItemName.climb]],
+    LocationName.strawberry_23: [[ItemName.cassette, ItemName.coin, ItemName.air_dash, ItemName.climb]],
     LocationName.strawberry_24: [[ItemName.cassette, ItemName.dash_refill, ItemName.traffic_block, ItemName.air_dash]],
-    LocationName.strawberry_25: [[ItemName.cassette, ItemName.dash_refill, ItemName.double_dash_refill, ItemName.air_dash, ItemName.climb],
-                                 [ItemName.cassette, ItemName.traffic_block, ItemName.feather, ItemName.double_dash_refill, ItemName.air_dash, ItemName.climb]],
-    LocationName.strawberry_26: [[ItemName.cassette, ItemName.dash_refill, ItemName.air_dash, ItemName.climb],
-                                 [ItemName.cassette, ItemName.traffic_block, ItemName.air_dash, ItemName.climb]],
-    LocationName.strawberry_27: [[ItemName.cassette, ItemName.dash_refill, ItemName.feather, ItemName.coin, ItemName.air_dash],
-                                 [ItemName.cassette, ItemName.traffic_block, ItemName.feather, ItemName.coin, ItemName.air_dash]],
-    LocationName.strawberry_28: [[ItemName.cassette, ItemName.dash_refill, ItemName.feather, ItemName.coin, ItemName.air_dash, ItemName.climb],
-                                 [ItemName.cassette, ItemName.traffic_block, ItemName.feather, ItemName.coin, ItemName.air_dash, ItemName.climb]],
-    LocationName.strawberry_29: [[ItemName.cassette, ItemName.dash_refill, ItemName.feather, ItemName.coin, ItemName.air_dash, ItemName.skid_jump]],
+    LocationName.strawberry_25: [[ItemName.cassette, ItemName.double_dash_refill, ItemName.air_dash, ItemName.climb]],
+    LocationName.strawberry_26: [[ItemName.cassette, ItemName.air_dash, ItemName.climb]],
+    LocationName.strawberry_27: [[ItemName.cassette, ItemName.feather, ItemName.coin, ItemName.air_dash, ItemName.climb]],
+    LocationName.strawberry_28: [[ItemName.cassette, ItemName.feather, ItemName.coin, ItemName.air_dash, ItemName.climb]],
+    LocationName.strawberry_29: [[ItemName.cassette, ItemName.dash_refill, ItemName.coin, ItemName.air_dash, ItemName.skid_jump]],
     LocationName.strawberry_30: [[ItemName.cassette, ItemName.dash_refill, ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.spring, ItemName.breakables, ItemName.air_dash, ItemName.climb]],
 
-    LocationName.granny_1:   [[ItemName.ground_dash],
-                              [ItemName.air_dash],
-                              [ItemName.skid_jump],
-                              [ItemName.climb]],
-    LocationName.granny_2:   [[ItemName.ground_dash],
-                              [ItemName.air_dash],
-                              [ItemName.skid_jump],
-                              [ItemName.climb]],
-    LocationName.granny_3:   [[ItemName.ground_dash],
-                              [ItemName.air_dash],
-                              [ItemName.skid_jump],
-                              [ItemName.climb]],
     LocationName.theo_1:     [[ItemName.traffic_block, ItemName.breakables, ItemName.air_dash]],
     LocationName.theo_2:     [[ItemName.traffic_block, ItemName.breakables, ItemName.air_dash]],
     LocationName.theo_3:     [[ItemName.traffic_block, ItemName.breakables, ItemName.air_dash]],
-    LocationName.badeline_1: [[ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.breakables, ItemName.air_dash, ItemName.climb]],
-    LocationName.badeline_2: [[ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.breakables, ItemName.air_dash, ItemName.climb]],
-    LocationName.badeline_3: [[ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.breakables, ItemName.air_dash, ItemName.climb]],
 
-    LocationName.sign_1: [[ItemName.ground_dash],
-                          [ItemName.air_dash],
-                          [ItemName.skid_jump],
-                          [ItemName.climb]],
     LocationName.sign_2: [[ItemName.breakables, ItemName.ground_dash],
                           [ItemName.breakables, ItemName.air_dash]],
-    LocationName.sign_3:  [[ItemName.dash_refill, ItemName.air_dash],
-                           [ItemName.traffic_block, ItemName.ground_dash],
-                           [ItemName.traffic_block, ItemName.air_dash],
-                           [ItemName.traffic_block, ItemName.skid_jump],
-                           [ItemName.traffic_block, ItemName.climb]],
-    LocationName.sign_4: [[ItemName.dash_refill, ItemName.double_dash_refill, ItemName.air_dash],
-                          [ItemName.dash_refill, ItemName.feather, ItemName.air_dash],
-                          [ItemName.traffic_block, ItemName.feather, ItemName.ground_dash],
-                          [ItemName.traffic_block, ItemName.feather, ItemName.air_dash],
-                          [ItemName.traffic_block, ItemName.feather, ItemName.skid_jump],
-                          [ItemName.traffic_block, ItemName.feather, ItemName.climb]],
-    LocationName.sign_5: [[ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.breakables, ItemName.air_dash, ItemName.climb]],
 
-    LocationName.car_2: [[ItemName.breakables, ItemName.ground_dash],
-                         [ItemName.breakables, ItemName.air_dash]],
+    LocationName.car_2: [[ItemName.breakables, ItemName.ground_dash, ItemName.climb],
+                         [ItemName.breakables, ItemName.air_dash, ItemName.climb]],
 }
 
 location_hard_moves_logic: Dict[str, List[List[str]]] = {
-    LocationName.strawberry_3:  [[ItemName.air_dash],
-                                 [ItemName.skid_jump]],
     LocationName.strawberry_5:  [[ItemName.ground_dash],
                                  [ItemName.air_dash]],
-    LocationName.strawberry_8:  [[ItemName.traffic_block],
-                                 [ItemName.ground_dash, ItemName.air_dash]],
     LocationName.strawberry_10: [[ItemName.air_dash],
                                  [ItemName.climb]],
     LocationName.strawberry_11: [[ItemName.ground_dash],
                                  [ItemName.air_dash],
                                  [ItemName.skid_jump]],
-    LocationName.strawberry_12: [[ItemName.feather],
-                                 [ItemName.ground_dash],
-                                 [ItemName.air_dash]],
     LocationName.strawberry_13: [[ItemName.breakables, ItemName.ground_dash],
                                  [ItemName.breakables, ItemName.air_dash]],
     LocationName.strawberry_14: [[ItemName.feather, ItemName.air_dash],
-                                 [ItemName.air_dash, ItemName.climb]],
+                                 [ItemName.air_dash, ItemName.climb],
+                                 [ItemName.double_dash_refill, ItemName.air_dash]],
     LocationName.strawberry_15: [[ItemName.feather],
                                  [ItemName.ground_dash, ItemName.air_dash]],
     LocationName.strawberry_17: [[ItemName.double_dash_refill, ItemName.traffic_block]],
@@ -287,42 +107,94 @@ location_hard_moves_logic: Dict[str, List[List[str]]] = {
                                  [ItemName.cassette, ItemName.feather, ItemName.climb]],
     LocationName.strawberry_29: [[ItemName.cassette, ItemName.dash_refill, ItemName.air_dash, ItemName.skid_jump],
                                  [ItemName.cassette, ItemName.ground_dash, ItemName.air_dash]],
-    LocationName.strawberry_30: [[ItemName.cassette, ItemName.dash_refill, ItemName.double_dash_refill, ItemName.traffic_block, ItemName.breakables, ItemName.ground_dash, ItemName.air_dash, ItemName.climb, ItemName.skid_jump],
-                                 [ItemName.cassette, ItemName.dash_refill, ItemName.double_dash_refill, ItemName.traffic_block, ItemName.breakables, ItemName.feather, ItemName.air_dash, ItemName.climb, ItemName.skid_jump],
-                                 [ItemName.cassette, ItemName.dash_refill, ItemName.double_dash_refill, ItemName.traffic_block, ItemName.breakables, ItemName.spring, ItemName.ground_dash, ItemName.air_dash, ItemName.climb],
-                                 [ItemName.cassette, ItemName.dash_refill, ItemName.double_dash_refill, ItemName.traffic_block, ItemName.breakables, ItemName.spring, ItemName.feather, ItemName.air_dash, ItemName.climb]],
-
-    LocationName.badeline_1: [[ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.breakables, ItemName.air_dash, ItemName.climb],
-                              [ItemName.traffic_block, ItemName.air_dash, ItemName.skid_jump],
-                              [ItemName.ground_dash, ItemName.air_dash, ItemName.skid_jump],
-                              [ItemName.feather, ItemName.traffic_block, ItemName.air_dash],
-                              [ItemName.traffic_block, ItemName.ground_dash, ItemName.air_dash]],
-    LocationName.badeline_2: [[ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.breakables, ItemName.air_dash, ItemName.climb],
-                              [ItemName.traffic_block, ItemName.air_dash, ItemName.skid_jump],
-                              [ItemName.ground_dash, ItemName.air_dash, ItemName.skid_jump],
-                              [ItemName.feather, ItemName.traffic_block, ItemName.air_dash],
-                              [ItemName.traffic_block, ItemName.ground_dash, ItemName.air_dash]],
-    LocationName.badeline_3: [[ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.breakables, ItemName.air_dash, ItemName.climb],
-                              [ItemName.traffic_block, ItemName.air_dash, ItemName.skid_jump],
-                              [ItemName.ground_dash, ItemName.air_dash, ItemName.skid_jump],
-                              [ItemName.feather, ItemName.traffic_block, ItemName.air_dash],
-                              [ItemName.traffic_block, ItemName.ground_dash, ItemName.air_dash]],
+    LocationName.strawberry_30: [[ItemName.cassette, ItemName.dash_refill, ItemName.double_dash_refill, ItemName.traffic_block, ItemName.breakables, ItemName.air_dash, ItemName.climb, ItemName.skid_jump],
+                                 [ItemName.cassette, ItemName.dash_refill, ItemName.double_dash_refill, ItemName.traffic_block, ItemName.breakables, ItemName.spring, ItemName.air_dash, ItemName.climb]],
 
     LocationName.sign_2: [[ItemName.breakables, ItemName.ground_dash],
                           [ItemName.breakables, ItemName.air_dash]],
-    LocationName.sign_5: [[ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.breakables, ItemName.air_dash, ItemName.climb],
-                          [ItemName.traffic_block, ItemName.air_dash, ItemName.skid_jump],
-                          [ItemName.ground_dash, ItemName.air_dash, ItemName.skid_jump],
-                          [ItemName.feather, ItemName.traffic_block, ItemName.air_dash],
-                          [ItemName.traffic_block, ItemName.ground_dash, ItemName.air_dash]],
 
     LocationName.car_2: [[ItemName.breakables, ItemName.ground_dash],
                          [ItemName.breakables, ItemName.air_dash]],
 }
 
 
-def location_rule(state: CollectionState, world: Celeste64World, loc: str) -> bool:
+region_standard_moves_logic: Dict[Tuple[str], List[List[str]]] = {
+    (RegionName.forsaken_city, RegionName.granny_island):        [[ItemName.checkpoint_2], [ItemName.checkpoint_3], [ItemName.checkpoint_4]],
+    (RegionName.forsaken_city, RegionName.highway_island):       [[ItemName.checkpoint_5], [ItemName.checkpoint_6]],
+    (RegionName.forsaken_city, RegionName.ne_feathers_island):   [[ItemName.checkpoint_7]],
+    (RegionName.forsaken_city, RegionName.se_house_island):      [[ItemName.checkpoint_8]],
+    (RegionName.forsaken_city, RegionName.badeline_tower_upper): [[ItemName.checkpoint_9]],
+    (RegionName.forsaken_city, RegionName.badeline_island):      [[ItemName.checkpoint_10]],
 
+    (RegionName.intro_islands, RegionName.granny_island): [[ItemName.ground_dash],
+                                                           [ItemName.air_dash],
+                                                           [ItemName.skid_jump],
+                                                           [ItemName.climb]],
+
+    (RegionName.granny_island, RegionName.highway_island): [[ItemName.air_dash, ItemName.dash_refill]],
+    (RegionName.granny_island, RegionName.nw_girders_island): [[ItemName.traffic_block]],
+    (RegionName.granny_island, RegionName.badeline_tower_lower): [[ItemName.air_dash, ItemName.climb, ItemName.dash_refill]],
+    (RegionName.granny_island, RegionName.se_house_island): [[ItemName.air_dash, ItemName.climb, ItemName.double_dash_refill]],
+    
+    (RegionName.highway_island, RegionName.granny_island): [[ItemName.traffic_block], [ItemName.air_dash, ItemName.dash_refill]],
+    (RegionName.highway_island, RegionName.ne_feathers_island): [[ItemName.feather]],
+    (RegionName.highway_island, RegionName.nw_girders_island): [[ItemName.cannot_access]],
+    
+    (RegionName.nw_girders_island, RegionName.highway_island): [[ItemName.traffic_block]],
+    
+    (RegionName.ne_feathers_island, RegionName.highway_island): [[ItemName.feather]],
+    (RegionName.ne_feathers_island, RegionName.badeline_tower_lower): [[ItemName.feather]],
+    (RegionName.ne_feathers_island, RegionName.badeline_tower_upper): [[ItemName.climb, ItemName.air_dash, ItemName.feather]],
+    
+    (RegionName.se_house_island, RegionName.granny_island): [[ItemName.air_dash, ItemName.traffic_block, ItemName.double_dash_refill]],
+    (RegionName.se_house_island, RegionName.badeline_tower_lower): [[ItemName.air_dash, ItemName.double_dash_refill]],
+    
+    (RegionName.badeline_tower_lower, RegionName.se_house_island): [[ItemName.cannot_access]],
+    (RegionName.badeline_tower_lower, RegionName.ne_feathers_island): [[ItemName.air_dash, ItemName.breakables, ItemName.feather]],
+    (RegionName.badeline_tower_lower, RegionName.granny_island): [[ItemName.cannot_access]],
+    (RegionName.badeline_tower_lower, RegionName.badeline_tower_upper): [[ItemName.cannot_access]],
+    
+    (RegionName.badeline_tower_upper, RegionName.badeline_island): [[ItemName.air_dash, ItemName.climb, ItemName.double_dash_refill, ItemName.feather, ItemName.traffic_block, ItemName.breakables]],
+    (RegionName.badeline_tower_upper, RegionName.se_house_island): [[ItemName.air_dash], [ItemName.ground_dash]],
+    (RegionName.badeline_tower_upper, RegionName.ne_feathers_island): [[ItemName.air_dash], [ItemName.ground_dash]],
+    (RegionName.badeline_tower_upper, RegionName.granny_island): [[ItemName.dash_refill]],
+    
+    (RegionName.badeline_island, RegionName.badeline_tower_upper): [[ItemName.air_dash], [ItemName.ground_dash]],
+}
+
+region_hard_moves_logic: Dict[Tuple[str], List[List[str]]] = {
+    (RegionName.forsaken_city, RegionName.granny_island):        [[ItemName.checkpoint_2], [ItemName.checkpoint_3], [ItemName.checkpoint_4]],
+    (RegionName.forsaken_city, RegionName.highway_island):       [[ItemName.checkpoint_5], [ItemName.checkpoint_6]],
+    (RegionName.forsaken_city, RegionName.ne_feathers_island):   [[ItemName.checkpoint_7]],
+    (RegionName.forsaken_city, RegionName.se_house_island):      [[ItemName.checkpoint_8]],
+    (RegionName.forsaken_city, RegionName.badeline_tower_upper): [[ItemName.checkpoint_9]],
+    (RegionName.forsaken_city, RegionName.badeline_island):      [[ItemName.checkpoint_10]],
+
+    (RegionName.granny_island, RegionName.nw_girders_island): [[ItemName.traffic_block]],
+    (RegionName.granny_island, RegionName.badeline_tower_lower): [[ItemName.air_dash], [ItemName.ground_dash]],
+    (RegionName.granny_island, RegionName.se_house_island): [[ItemName.air_dash, ItemName.double_dash_refill], [ItemName.ground_dash]],
+    
+    (RegionName.highway_island, RegionName.nw_girders_island): [[ItemName.air_dash, ItemName.ground_dash]],
+    
+    (RegionName.nw_girders_island, RegionName.highway_island): [[ItemName.traffic_block], [ItemName.air_dash, ItemName.ground_dash]],
+    
+    (RegionName.ne_feathers_island, RegionName.highway_island): [[ItemName.feather], [ItemName.air_dash], [ItemName.ground_dash], [ItemName.skid_jump]],
+    (RegionName.ne_feathers_island, RegionName.badeline_tower_lower): [[ItemName.feather], [ItemName.air_dash], [ItemName.ground_dash]],
+    (RegionName.ne_feathers_island, RegionName.badeline_tower_upper): [[ItemName.feather]],
+    
+    (RegionName.se_house_island, RegionName.granny_island): [[ItemName.traffic_block]],
+    (RegionName.se_house_island, RegionName.badeline_tower_lower): [[ItemName.air_dash], [ItemName.ground_dash]],
+    
+    (RegionName.badeline_tower_upper, RegionName.badeline_island): [[ItemName.air_dash, ItemName.climb, ItemName.feather, ItemName.traffic_block],
+                                                                    [ItemName.air_dash, ItemName.climb, ItemName.feather, ItemName.skid_jump],
+                                                                    [ItemName.air_dash, ItemName.climb, ItemName.ground_dash, ItemName.traffic_block],
+                                                                    [ItemName.air_dash, ItemName.climb, ItemName.ground_dash, ItemName.skid_jump]],
+
+    (RegionName.badeline_island, RegionName.badeline_tower_upper): [[ItemName.air_dash], [ItemName.ground_dash]],
+}
+
+
+def location_rule(state: CollectionState, world: Celeste64World, loc: str) -> bool:
     if loc not in world.active_logic_mapping:
         return True
 
@@ -332,12 +204,28 @@ def location_rule(state: CollectionState, world: Celeste64World, loc: str) -> bo
 
     return False
 
-def goal_rule(state: CollectionState, world: Celeste64World) -> bool:
-    if not state.has(ItemName.strawberry, world.player, world.strawberries_required):
-        return False
+def region_connection_rule(state: CollectionState, world: Celeste64World, region_connection: Tuple[str]) -> bool:
+    if region_connection not in world.active_region_logic_mapping:
+        return True
 
-    for possible_access in world.goal_logic_mapping:
+    for possible_access in world.active_region_logic_mapping[region_connection]:
         if state.has_all(possible_access, world.player):
             return True
 
     return False
+
+def goal_rule(state: CollectionState, world: Celeste64World) -> bool:
+    if not state.has(ItemName.strawberry, world.player, world.strawberries_required):
+        return False
+
+    goal_region: Region = world.multiworld.get_region(RegionName.badeline_island, world.player)
+    return state.can_reach(goal_region)
+
+def connect_region(world: Celeste64World, region: Region, dest_regions: List[str]):
+    rules: Dict[str, Callable[[CollectionState], bool]] = {}
+
+    for dest_region in dest_regions:
+        region_connection: Tuple[str] = (region.name, dest_region)
+        rules[dest_region] = lambda state, region_connection=region_connection: region_connection_rule(state, world, region_connection)
+
+    region.add_exits(dest_regions, rules)

worlds/celeste64/__init__.py

@@ -1,13 +1,15 @@
 from copy import deepcopy
-from typing import Dict, List
+from typing import Dict, List, Tuple
 
 from BaseClasses import ItemClassification, Location, Region, Tutorial
 from worlds.AutoWorld import WebWorld, World
-from .Items import Celeste64Item, unlockable_item_data_table, move_item_data_table, item_data_table, item_table
+from .Items import Celeste64Item, unlockable_item_data_table, move_item_data_table, item_data_table,\
+                                  checkpoint_item_data_table, item_table
 from .Locations import Celeste64Location, strawberry_location_data_table, friend_location_data_table,\
-                                          sign_location_data_table, car_location_data_table, location_table
+                                          sign_location_data_table, car_location_data_table, checkpoint_location_data_table,\
+                                          location_table
 from .Names import ItemName, LocationName
-from .Options import Celeste64Options, celeste_64_option_groups
+from .Options import Celeste64Options, celeste_64_option_groups, resolve_options
 
 
 class Celeste64WebWorld(WebWorld):
@@ -42,8 +44,15 @@ class Celeste64World(World):
     # Instance Data
     strawberries_required: int
     active_logic_mapping: Dict[str, List[List[str]]]
-    goal_logic_mapping: Dict[str, List[List[str]]]
+    active_region_logic_mapping: Dict[Tuple[str], List[List[str]]]
 
+    madeline_one_dash_hair_color: int
+    madeline_two_dash_hair_color: int
+    madeline_no_dash_hair_color: int
+    madeline_feather_hair_color: int
+
+    def generate_early(self) -> None:
+        resolve_options(self)
 
     def create_item(self, name: str) -> Celeste64Item:
         # Only make required amount of strawberries be Progression
@@ -76,25 +85,49 @@ class Celeste64World(World):
                       for name in unlockable_item_data_table.keys()
                       if name not in self.options.start_inventory]
 
-        if self.options.move_shuffle:
-            move_items_for_itempool: List[str] = deepcopy(list(move_item_data_table.keys()))
+        chosen_start_item: str = ""
 
+        if self.options.move_shuffle:
             if self.options.logic_difficulty == "standard":
-                # If the start_inventory already includes a move, don't worry about giving it one
-                if not [move for move in move_items_for_itempool if move in self.options.start_inventory]:
-                    chosen_start_move = self.random.choice(move_items_for_itempool)
-                    move_items_for_itempool.remove(chosen_start_move)
+                possible_unwalls: List[str] = [name for name in move_item_data_table.keys()
+                                                if name != ItemName.skid_jump]
+
+                if self.options.checkpointsanity:
+                    possible_unwalls.extend([name for name in checkpoint_item_data_table.keys()
+                                                if name != ItemName.checkpoint_1 and name != ItemName.checkpoint_10])
+
+                # If the start_inventory already includes a move or checkpoint, don't worry about giving it one
+                if not [item for item in possible_unwalls if item in self.multiworld.precollected_items[self.player]]:
+                    chosen_start_item = self.random.choice(possible_unwalls)
 
                     if self.options.carsanity:
                         intro_car_loc: Location = self.multiworld.get_location(LocationName.car_1, self.player)
-                        intro_car_loc.place_locked_item(self.create_item(chosen_start_move))
+                        intro_car_loc.place_locked_item(self.create_item(chosen_start_item))
                         location_count -= 1
                     else:
-                        self.multiworld.push_precollected(self.create_item(chosen_start_move))
+                        self.multiworld.push_precollected(self.create_item(chosen_start_item))
 
             item_pool += [self.create_item(name)
-                          for name in move_items_for_itempool
-                          if name not in self.options.start_inventory]
+                          for name in move_item_data_table.keys()
+                          if name not in self.multiworld.precollected_items[self.player]
+                          and name != chosen_start_item]
+        else:
+            for start_move in move_item_data_table.keys():
+                self.multiworld.push_precollected(self.create_item(start_move))
+
+        if self.options.checkpointsanity:
+            location_count += 9
+            goal_checkpoint_loc: Location = self.multiworld.get_location(LocationName.checkpoint_10, self.player)
+            goal_checkpoint_loc.place_locked_item(self.create_item(ItemName.checkpoint_10))
+            item_pool += [self.create_item(name)
+                          for name in checkpoint_item_data_table.keys()
+                          if name not in self.multiworld.precollected_items[self.player]
+                          and name != ItemName.checkpoint_10
+                          and name != chosen_start_item]
+        else:
+            for item_name in checkpoint_item_data_table.keys():
+                checkpoint_loc: Location = self.multiworld.get_location(item_name, self.player)
+                checkpoint_loc.place_locked_item(self.create_item(item_name))
 
         real_total_strawberries: int = min(self.options.total_strawberries.value, location_count - len(item_pool))
         self.strawberries_required = int(real_total_strawberries * (self.options.strawberries_required_percentage / 100))
@@ -140,18 +173,23 @@ class Celeste64World(World):
                     if location_data.region == region_name
                 }, Celeste64Location)
 
-            region.add_exits(region_data_table[region_name].connecting_regions)
+            region.add_locations({
+                location_name: location_data.address for location_name, location_data in checkpoint_location_data_table.items()
+                if location_data.region == region_name
+            }, Celeste64Location)
+
+            from .Rules import connect_region
+            connect_region(self, region, region_data_table[region_name].connecting_regions)
+
+        # Have to do this here because of other games using State in a way that's bad
+        from .Rules import set_rules
+        set_rules(self)
 
 
     def get_filler_item_name(self) -> str:
         return ItemName.raspberry
 
 
-    def set_rules(self) -> None:
-        from .Rules import set_rules
-        set_rules(self)
-
-
     def fill_slot_data(self):
         return {
             "death_link": self.options.death_link.value,
@@ -161,6 +199,11 @@ class Celeste64World(World):
             "friendsanity": self.options.friendsanity.value,
             "signsanity": self.options.signsanity.value,
             "carsanity": self.options.carsanity.value,
+            "checkpointsanity": self.options.checkpointsanity.value,
+            "madeline_one_dash_hair_color": self.madeline_one_dash_hair_color,
+            "madeline_two_dash_hair_color": self.madeline_two_dash_hair_color,
+            "madeline_no_dash_hair_color": self.madeline_no_dash_hair_color,
+            "madeline_feather_hair_color": self.madeline_feather_hair_color,
             "badeline_chaser_source": self.options.badeline_chaser_source.value,
             "badeline_chaser_frequency": self.options.badeline_chaser_frequency.value,
             "badeline_chaser_speed": self.options.badeline_chaser_speed.value,

worlds/celeste64/docs/guide_en.md

@@ -12,6 +12,12 @@
 
 1. Download the above release and extract it.
 
+## Installation Procedures (Linux and Steam Deck)
+
+1. Download the above release and extract it.
+
+2. Add Celeste64.exe to Steam as a Non-Steam Game. In the properties for it on Steam, set it to use Proton as the compatibility tool. Launch the game through Steam in order to run it.
+
 ## Joining a MultiWorld Game
 
 1. Before launching the game, edit the `AP.json` file in the root of the Celeste 64 install.
@@ -33,5 +39,3 @@ An Example `AP.json` file:
 	"Password": ""
 }
 ```
-
-

worlds/civ_6/Civ6Client.py

@@ -0,0 +1,342 @@
+import asyncio
+import logging
+import os
+import traceback
+from typing import Any, Dict, List, Optional
+import zipfile
+
+from CommonClient import ClientCommandProcessor, CommonContext, get_base_parser, logger, server_loop, gui_enabled
+from .Data import get_progressive_districts_data
+from .DeathLink import handle_check_deathlink
+from NetUtils import ClientStatus
+import Utils
+from .CivVIInterface import CivVIInterface, ConnectionState
+from .Enum import CivVICheckType
+from .Items import CivVIItemData, generate_item_table, get_item_by_civ_name
+from .Locations import CivVILocationData, generate_era_location_table
+from .TunerClient import TunerErrorException, TunerTimeoutException
+
+
+class CivVICommandProcessor(ClientCommandProcessor):
+    def __init__(self, ctx: CommonContext):
+        super().__init__(ctx)
+
+    def _cmd_deathlink(self):
+        """Toggle deathlink from client. Overrides default setting."""
+        if isinstance(self.ctx, CivVIContext):
+            self.ctx.death_link_enabled = not self.ctx.death_link_enabled
+            self.ctx.death_link_just_changed = True
+            Utils.async_start(self.ctx.update_death_link(
+                self.ctx.death_link_enabled), name="Update Deathlink")
+            self.ctx.logger.info(f"Deathlink is now {'enabled' if self.ctx.death_link_enabled else 'disabled'}")
+
+    def _cmd_resync(self):
+        """Resends all items to client, and has client resend all locations to server. This can take up to a minute if the player has received a lot of items"""
+        if isinstance(self.ctx, CivVIContext):
+            logger.info("Resyncing...")
+            asyncio.create_task(self.ctx.resync())
+
+    def _cmd_toggle_progressive_eras(self):
+        """If you get stuck for some reason and unable to continue your game, you can run this command to disable the defeat that comes from pushing past the max unlocked era """
+        if isinstance(self.ctx, CivVIContext):
+            print("Toggling progressive eras, stand by...")
+            self.ctx.is_pending_toggle_progressive_eras = True
+
+
+class CivVIContext(CommonContext):
+    is_pending_death_link_reset = False
+    is_pending_toggle_progressive_eras = False
+    command_processor = CivVICommandProcessor
+    game = "Civilization VI"
+    items_handling = 0b111
+    tuner_sync_task: Optional[asyncio.Task[None]] = None
+    game_interface: CivVIInterface
+    location_name_to_civ_location: Dict[str, CivVILocationData] = {}
+    location_name_to_id: Dict[str, int] = {}
+    item_id_to_civ_item: Dict[int, CivVIItemData] = {}
+    item_table: Dict[str, CivVIItemData] = {}
+    processing_multiple_items = False
+    received_death_link = False
+    death_link_message = ""
+    death_link_enabled = False
+    slot_data: Dict[str, Any]
+
+    death_link_just_changed = False
+    # Used to prevent the deathlink from triggering when someone re enables it
+
+    logger = logger
+    progressive_items_by_type = get_progressive_districts_data()
+    item_name_to_id = {
+        item.name: item.code for item in generate_item_table().values()}
+    connection_state = ConnectionState.DISCONNECTED
+
+    def __init__(self, server_address: Optional[str], password: Optional[str], apcivvi_file: Optional[str] = None):
+        super().__init__(server_address, password)
+        self.slot_data: Dict[str, Any] = {}
+        self.game_interface = CivVIInterface(logger)
+        location_by_era = generate_era_location_table()
+        self.item_table = generate_item_table()
+        self.apcivvi_file = apcivvi_file
+
+        # Get tables formatted in a way that is easier to use here
+        for locations in location_by_era.values():
+            for location in locations.values():
+                self.location_name_to_id[location.name] = location.code
+                self.location_name_to_civ_location[location.name] = location
+
+        for item in self.item_table.values():
+            self.item_id_to_civ_item[item.code] = item
+
+    async def resync(self):
+        if self.processing_multiple_items:
+            logger.info(
+                "Waiting for items to finish processing, try again later")
+            return
+        await self.game_interface.resync()
+        await handle_receive_items(self, -1)
+        logger.info("Resynced")
+
+    def on_deathlink(self, data: Utils.Dict[str, Utils.Any]) -> None:
+        super().on_deathlink(data)
+        text = data.get("cause", "")
+        if text:
+            message = text
+        else:
+            message = f"Received from {data['source']}"
+        self.death_link_message = message
+        self.received_death_link = True
+
+    async def server_auth(self, password_requested: bool = False):
+        if password_requested and not self.password:
+            await super(CivVIContext, self).server_auth(password_requested)
+        await self.get_username()
+        self.tags = set()
+        await self.send_connect()
+
+    def run_gui(self):
+        from kvui import GameManager
+
+        class CivVIManager(GameManager):
+            logging_pairs = [
+                ("Client", "Archipelago")
+            ]
+            base_title = "Archipelago Civilization VI Client"
+
+        self.ui = CivVIManager(self)
+        self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
+
+    def on_package(self, cmd: str, args: Dict[str, Any]):
+        if cmd == "Connected":
+            self.slot_data = args["slot_data"]
+            if "death_link" in args["slot_data"]:
+                self.death_link_enabled = bool(args["slot_data"]["death_link"])
+                Utils.async_start(self.update_death_link(
+                    bool(args["slot_data"]["death_link"])))
+
+
+def update_connection_status(ctx: CivVIContext, status: ConnectionState):
+    if ctx.connection_state == status:
+        return
+    elif status == ConnectionState.IN_GAME:
+        ctx.logger.info("Connected to Civ VI")
+    elif status == ConnectionState.IN_MENU:
+        ctx.logger.info("Connected to Civ VI, waiting for game to start")
+    elif status == ConnectionState.DISCONNECTED:
+        ctx.logger.info("Disconnected from Civ VI, attempting to reconnect...")
+
+    ctx.connection_state = status
+
+
+async def tuner_sync_task(ctx: CivVIContext):
+    logger.info("Starting CivVI connector")
+    while not ctx.exit_event.is_set():
+        if not ctx.slot:
+            await asyncio.sleep(3)
+            continue
+        else:
+            try:
+                if ctx.processing_multiple_items:
+                    await asyncio.sleep(3)
+                else:
+                    state = await ctx.game_interface.is_in_game()
+                    update_connection_status(ctx, state)
+                    if state == ConnectionState.IN_GAME:
+                        await _handle_game_ready(ctx)
+                    else:
+                        await asyncio.sleep(3)
+            except TunerTimeoutException:
+                logger.error(
+                    "Timeout occurred while receiving data from Civ VI, this usually isn't a problem unless you see it repeatedly")
+                await asyncio.sleep(3)
+            except Exception as e:
+                if isinstance(e, TunerErrorException):
+                    logger.debug(str(e))
+                else:
+                    logger.debug(traceback.format_exc())
+
+                await asyncio.sleep(3)
+                continue
+
+
+async def handle_toggle_progressive_eras(ctx: CivVIContext):
+    if ctx.is_pending_toggle_progressive_eras:
+        ctx.is_pending_toggle_progressive_eras = False
+        current = await ctx.game_interface.get_max_allowed_era()
+        if current > -1:
+            await ctx.game_interface.set_max_allowed_era(-1)
+            logger.info("Disabled progressive eras")
+        else:
+            count = 0
+            for _, network_item in enumerate(ctx.items_received):
+                item: CivVIItemData = ctx.item_id_to_civ_item[network_item.item]
+                if item.item_type == CivVICheckType.ERA:
+                    count += 1
+            await ctx.game_interface.set_max_allowed_era(count)
+            logger.info(f"Enabled progressive eras, set to {count}")
+
+
+async def handle_checked_location(ctx: CivVIContext):
+    checked_locations = await ctx.game_interface.get_checked_locations()
+    checked_location_ids = [location.code for location_name, location in ctx.location_name_to_civ_location.items(
+    ) if location_name in checked_locations]
+
+    await ctx.send_msgs([{"cmd": "LocationChecks", "locations": checked_location_ids}])
+
+
+async def handle_receive_items(ctx: CivVIContext, last_received_index_override: Optional[int] = None):
+    try:
+        last_received_index = last_received_index_override or await ctx.game_interface.get_last_received_index()
+        if len(ctx.items_received) - last_received_index > 1:
+            ctx.processing_multiple_items = True
+
+        progressive_districts: List[CivVIItemData] = []
+        progressive_eras: List[CivVIItemData] = []
+        for index, network_item in enumerate(ctx.items_received):
+
+            # Track these separately so if we replace "PROGRESSIVE_DISTRICT" with a specific tech, we can still check if need to add it to the list of districts
+            item: CivVIItemData = ctx.item_id_to_civ_item[network_item.item]
+            item_to_send: CivVIItemData = ctx.item_id_to_civ_item[network_item.item]
+            if index > last_received_index:
+                if item.item_type == CivVICheckType.PROGRESSIVE_DISTRICT and item.civ_name:
+                    # if the item is progressive, then check how far in that progression type we are and send the appropriate item
+                    count = sum(
+                        1 for count_item in progressive_districts if count_item.civ_name == item.civ_name)
+
+                    if count >= len(ctx.progressive_items_by_type[item.civ_name]):
+                        logger.error(
+                            f"Received more progressive items than expected for {item.civ_name}")
+                        continue
+
+                    item_civ_name = ctx.progressive_items_by_type[item.civ_name][count]
+                    actual_item_name = get_item_by_civ_name(item_civ_name, ctx.item_table).name
+                    item_to_send = ctx.item_table[actual_item_name]
+
+                sender = ctx.player_names[network_item.player]
+                if item.item_type == CivVICheckType.ERA:
+                    count = len(progressive_eras) + 1
+                    await ctx.game_interface.give_item_to_player(item_to_send, sender, count)
+                elif item.item_type == CivVICheckType.GOODY and item_to_send.civ_name:
+                    await ctx.game_interface.give_item_to_player(item_to_send, sender, game_id_override=item_to_send.civ_name)
+                else:
+                    await ctx.game_interface.give_item_to_player(item_to_send, sender)
+                await asyncio.sleep(0.02)
+
+            if item.item_type == CivVICheckType.PROGRESSIVE_DISTRICT:
+                progressive_districts.append(item)
+            elif item.item_type == CivVICheckType.ERA:
+                progressive_eras.append(item)
+
+        ctx.processing_multiple_items = False
+    finally:
+        # If something errors out, then unblock item processing
+        ctx.processing_multiple_items = False
+
+
+async def handle_check_goal_complete(ctx: CivVIContext):
+    if ctx.finished_game:
+        return
+    result = await ctx.game_interface.check_victory()
+    if result:
+        logger.info("Sending Victory to server!")
+        await ctx.send_msgs([{"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}])
+        ctx.finished_game = True
+
+
+async def _handle_game_ready(ctx: CivVIContext):
+    if ctx.server:
+        if not ctx.slot:
+            await asyncio.sleep(3)
+            return
+
+        await handle_receive_items(ctx)
+        await handle_checked_location(ctx)
+        await handle_check_goal_complete(ctx)
+
+        if ctx.death_link_enabled:
+            await handle_check_deathlink(ctx)
+
+        # process pending commands
+        await handle_toggle_progressive_eras(ctx)
+        await asyncio.sleep(3)
+    else:
+        logger.info("Waiting for player to connect to server")
+        await asyncio.sleep(3)
+
+
+def main(connect: Optional[str] = None, password: Optional[str] = None, name: Optional[str] = None):
+    Utils.init_logging("Civilization VI Client")
+
+    async def _main(connect: Optional[str], password: Optional[str], name: Optional[str]):
+        parser = get_base_parser()
+        parser.add_argument("apcivvi_file", default="", type=str, nargs="?", help="Path to apcivvi file")
+        args = parser.parse_args()
+        ctx = CivVIContext(connect, password, args.apcivvi_file)
+
+        if args.apcivvi_file:
+            parent_dir: str = os.path.dirname(args.apcivvi_file)
+            target_name: str = os.path.basename(args.apcivvi_file).replace(".apcivvi", "-MOD-FILES")
+            target_path: str = os.path.join(parent_dir, target_name)
+            if not os.path.exists(target_path):
+                os.makedirs(target_path, exist_ok=True)
+                logger.info("Extracting mod files to %s", target_path)
+                with zipfile.ZipFile(args.apcivvi_file, "r") as zip_ref:
+                    for member in zip_ref.namelist():
+                        zip_ref.extract(member, target_path)
+
+        ctx.auth = name
+        ctx.server_task = asyncio.create_task(
+            server_loop(ctx), name="ServerLoop")
+        if gui_enabled:
+            ctx.run_gui()
+        await asyncio.sleep(1)
+
+        ctx.tuner_sync_task = asyncio.create_task(
+            tuner_sync_task(ctx), name="TunerSync")
+
+        await ctx.exit_event.wait()
+        ctx.server_address = None
+
+        await ctx.shutdown()
+
+        if ctx.tuner_sync_task:
+            await asyncio.sleep(3)
+            await ctx.tuner_sync_task
+
+    import colorama
+
+    colorama.init()
+    asyncio.run(_main(connect, password, name))
+    colorama.deinit()
+
+
+def debug_main():
+    parser = get_base_parser()
+    parser.add_argument("apcivvi_file", default="", type=str, nargs="?", help="Path to apcivvi file")
+    parser.add_argument("--name", default=None,
+                        help="Slot Name to connect as.")
+    parser.add_argument("--debug", default=None,
+                        help="debug mode, additional logging")
+    args = parser.parse_args()
+    if args.debug:
+        logger.setLevel(logging.DEBUG)
+    main(args.connect, args.password, args.name)

worlds/civ_6/CivVIInterface.py

@@ -0,0 +1,119 @@
+from enum import Enum
+from logging import Logger
+from typing import List, Optional
+
+from .Items import CivVIItemData
+from .TunerClient import TunerClient, TunerConnectionException, TunerTimeoutException
+
+
+class ConnectionState(Enum):
+    DISCONNECTED = 0
+    IN_GAME = 1
+    IN_MENU = 2
+
+
+class CivVIInterface:
+    logger: Logger
+    tuner: TunerClient
+    last_error: Optional[str] = None
+
+    def __init__(self, logger: Logger):
+        self.logger = logger
+        self.tuner = TunerClient(logger)
+
+    async def is_in_game(self) -> ConnectionState:
+        command = "IsInGame()"
+        try:
+            result = await self.tuner.send_game_command(command)
+            if result == "false":
+                return ConnectionState.IN_MENU
+            self.last_error = None
+            return ConnectionState.IN_GAME
+        except TunerTimeoutException:
+            self.print_connection_error(
+                "Not connected to game, waiting for connection to be available")
+            return ConnectionState.DISCONNECTED
+        except TunerConnectionException as e:
+            if "The remote computer refused the network connection" in str(e):
+                self.print_connection_error(
+                    "Unable to connect to game. Verify that the tuner is enabled. Attempting to reconnect")
+            else:
+                self.print_connection_error(
+                    "Not connected to game, waiting for connection to be available")
+            return ConnectionState.DISCONNECTED
+        except Exception as e:
+            if "attempt to index a nil valuestack traceback" in str(e) \
+                    or ".. is not supported for string .. nilstack traceback" in str(e):
+                return ConnectionState.IN_MENU
+        return ConnectionState.DISCONNECTED
+
+    def print_connection_error(self, error: str) -> None:
+        if error != self.last_error:
+            self.last_error = error
+            self.logger.info(error)
+
+    async def give_item_to_player(self, item: CivVIItemData, sender: str = "", amount: int = 1, game_id_override: Optional[str] = None) -> None:
+        if game_id_override:
+            item_id = f'"{game_id_override}"'
+        else:
+            item_id = item.civ_vi_id
+
+        command = f"HandleReceiveItem({item_id}, \"{item.name}\", \"{item.item_type.value}\", \"{sender}\", {amount})"
+        await self.tuner.send_game_command(command)
+
+    async def resync(self) -> None:
+        """Has the client resend all the checked locations"""
+        command = "Resync()"
+        await self.tuner.send_game_command(command)
+
+    async def check_victory(self) -> bool:
+        command = "ClientGetVictory()"
+        result = await self.tuner.send_game_command(command)
+        return result == "true"
+
+    async def get_checked_locations(self) -> List[str]:
+        command = "GetUnsentCheckedLocations()"
+        result = await self.tuner.send_game_command(command, 2048 * 4)
+        return result.split(",")
+
+    async def get_deathlink(self) -> str:
+        """returns either "false" or the name of the unit that killed the player's unit"""
+        command = "ClientGetDeathLink()"
+        result = await self.tuner.send_game_command(command)
+        return result
+
+    async def kill_unit(self, message: str) -> None:
+        command = f"KillUnit(\"{message}\")"
+        await self.tuner.send_game_command(command)
+
+    async def get_last_received_index(self) -> int:
+        command = "ClientGetLastReceivedIndex()"
+        result = await self.tuner.send_game_command(command)
+        return int(result)
+
+    async def send_notification(self, item: CivVIItemData, sender: str = "someone") -> None:
+        command = f"GameCore.NotificationManager:SendNotification(GameCore.NotificationTypes.USER_DEFINED_2, \"{item.name} Received\", \"You have received {item.name} from \" .. \"{sender}\", 0, {item.civ_vi_id})"
+        await self.tuner.send_command(command)
+
+    async def decrease_gold_by_percent(self, percent: int, message: str) -> None:
+        command = f"DecreaseGoldByPercent({percent}, \"{message}\")"
+        await self.tuner.send_game_command(command)
+
+    async def decrease_faith_by_percent(self, percent: int, message: str) -> None:
+        command = f"DecreaseFaithByPercent({percent}, \"{message}\")"
+        await self.tuner.send_game_command(command)
+
+    async def decrease_era_score_by_amount(self, amount: int, message: str) -> None:
+        command = f"DecreaseEraScoreByAmount({amount}, \"{message}\")"
+        await self.tuner.send_game_command(command)
+
+    async def set_max_allowed_era(self, count: int) -> None:
+        command = f"SetMaxAllowedEra(\"{count}\")"
+        await self.tuner.send_game_command(command)
+
+    async def get_max_allowed_era(self) -> int:
+        command = "ClientGetMaxAllowedEra()"
+        result = await self.tuner.send_game_command(command)
+        if result == "":
+            return -1
+        return int(result)

worlds/civ_6/Container.py

@@ -0,0 +1,228 @@
+from dataclasses import dataclass
+import os
+import io
+from typing import TYPE_CHECKING, Dict, List, Optional, cast
+import zipfile
+from BaseClasses import Location
+from worlds.Files import APContainer, AutoPatchRegister
+
+from .Enum import CivVICheckType
+from .Locations import CivVILocation, CivVILocationData
+
+if TYPE_CHECKING:
+    from . import CivVIWorld
+
+
+# Python fstrings don't allow backslashes, so we use this workaround
+nl = "\n"
+tab = "\t"
+apo = "\'"
+
+
+@dataclass
+class CivTreeItem:
+    name: str
+    cost: int
+    ui_tree_row: int
+
+
+class CivVIContainer(APContainer, metaclass=AutoPatchRegister):
+    """
+    Responsible for generating the dynamic mod files for the Civ VI multiworld
+    """
+    game: Optional[str] = "Civilization VI"
+    patch_file_ending = ".apcivvi"
+
+    def __init__(self, patch_data: Dict[str, str] | io.BytesIO, base_path: str = "", output_directory: str = "",
+                 player: Optional[int] = None, player_name: str = "", server: str = ""):
+        if isinstance(patch_data, io.BytesIO):
+            super().__init__(patch_data, player, player_name, server)
+        else:
+            self.patch_data = patch_data
+            self.file_path = base_path
+            container_path = os.path.join(output_directory, base_path + ".apcivvi")
+            super().__init__(container_path, player, player_name, server)
+
+    def write_contents(self, opened_zipfile: zipfile.ZipFile) -> None:
+        for filename, yml in self.patch_data.items():
+            opened_zipfile.writestr(filename, yml)
+        super().write_contents(opened_zipfile)
+
+def sanitize_value(value: str) -> str:
+  """Removes values that can cause issues in XML"""
+  return value.replace('"', "'").replace('&', 'and')
+
+
+def get_cost(world: 'CivVIWorld', location: CivVILocationData) -> int:
+    """
+    Returns the cost of the item based on the game options
+    """
+    # Research cost is between 50 and 150 where 100 equals the default cost
+    multiplier = world.options.research_cost_multiplier / 100
+    return int(world.location_table[location.name].cost * multiplier)
+
+
+def get_formatted_player_name(world: 'CivVIWorld', player: int) -> str:
+    """
+    Returns the name of the player in the world
+    """
+    if player != world.player:
+        return sanitize_value(f"{world.multiworld.player_name[player]}{apo}s")
+    return "Your"
+
+
+def get_advisor_type(world: 'CivVIWorld', location: Location) -> str:
+    if world.options.advisor_show_progression_items and location.item and location.item.advancement:
+        return "ADVISOR_PROGRESSIVE"
+    return "ADVISOR_GENERIC"
+
+
+def generate_new_items(world: 'CivVIWorld') -> str:
+    """
+    Generates the XML for the new techs/civics as well as the blockers used to prevent players from researching their own items
+    """
+    locations: List[CivVILocation] = cast(List[CivVILocation], world.multiworld.get_filled_locations(world.player))
+    techs = [location for location in locations if location.location_type ==
+             CivVICheckType.TECH]
+    civics = [location for location in locations if location.location_type ==
+              CivVICheckType.CIVIC]
+
+    boost_techs = []
+    boost_civics = []
+
+    if world.options.boostsanity:
+        boost_techs = [location for location in locations if location.location_type == CivVICheckType.BOOST and location.name.split("_")[1] == "TECH"]
+        boost_civics = [location for location in locations if location.location_type == CivVICheckType.BOOST and location.name.split("_")[1] == "CIVIC"]
+        techs += boost_techs
+        civics += boost_civics
+
+    return f"""<?xml version="1.0" encoding="utf-8"?>
+<GameInfo>
+  <Types>
+    <Row Type="TECH_BLOCKER" Kind="KIND_TECH" />
+    <Row Type="CIVIC_BLOCKER" Kind="KIND_CIVIC" />
+  {"".join([f'{tab}<Row Type="{tech.name}" Kind="KIND_TECH" />{nl}' for
+           tech in techs])}
+  {"".join([f'{tab}<Row Type="{civic.name}" Kind="KIND_CIVIC" />{nl}' for
+            civic in civics])}
+  </Types>
+  <Technologies>
+      <Row TechnologyType="TECH_BLOCKER" Name="TECH_BLOCKER" EraType="ERA_ANCIENT" UITreeRow="0" Cost="99999" AdvisorType="ADVISOR_GENERIC" Description="Archipelago Tech created to prevent players from researching their own tech. If you can read this, then congrats you have reached the end of your tree before beating the game!"/>
+{"".join([f'{tab}<Row TechnologyType="{location.name}" '
+                f'Name="{get_formatted_player_name(world, location.item.player)} '
+                f'{sanitize_value(location.item.name)}" '
+                f'EraType="{world.location_table[location.name].era_type}" '
+                f'UITreeRow="{world.location_table[location.name].uiTreeRow}" '
+                f'Cost="{get_cost(world, world.location_table[location.name])}" '
+                f'Description="{location.name}" '
+                f'AdvisorType="{get_advisor_type(world, location)}"'
+                f'/>{nl}'
+                for location in techs if location.item])}
+  </Technologies>
+  <TechnologyPrereqs>
+  {"".join([f'{tab}<Row Technology="{location.name}" PrereqTech="TECH_BLOCKER" />{nl}' for location in boost_techs])}
+  </TechnologyPrereqs>
+  <Civics>
+      <Row CivicType="CIVIC_BLOCKER" Name="CIVIC_BLOCKER" EraType="ERA_ANCIENT" UITreeRow="0" Cost="99999" AdvisorType="ADVISOR_GENERIC" Description="Archipelago Civic created to prevent players from researching their own civics. If you can read this, then congrats you have reached the end of your tree before beating the game!"/>
+{"".join([f'{tab}<Row CivicType="{location.name}" '
+                    f'Name="{get_formatted_player_name(world, location.item.player)} '
+                    f'{sanitize_value(location.item.name)}" '
+                    f'EraType="{world.location_table[location.name].era_type}" '
+                    f'UITreeRow="{world.location_table[location.name].uiTreeRow}" '
+                    f'Cost="{get_cost(world, world.location_table[location.name])}" '
+                    f'Description="{location.name}" '
+                    f'AdvisorType="{get_advisor_type(world, location)}"'
+                    f'/>{nl}'
+                    for location in civics if location.item])}
+  </Civics>
+  <CivicPrereqs>
+  {"".join([f'{tab}<Row Civic="{location.name}" PrereqCivic="CIVIC_BLOCKER" />{nl}' for location in boost_civics])}
+  </CivicPrereqs>
+
+  <Civics_XP2>
+    {"".join([f'{tab}<Row CivicType="{location.name}" HiddenUntilPrereqComplete="true" RandomPrereqs="false"/>{nl}' for location in civics if world.options.hide_item_names])}
+  </Civics_XP2>
+
+  <Technologies_XP2>
+    {"".join([f'{tab}<Row TechnologyType="{location.name}" HiddenUntilPrereqComplete="true" RandomPrereqs="false"/>{nl}' for location in techs if world.options.hide_item_names])}
+  </Technologies_XP2>
+
+</GameInfo>
+    """
+
+
+def generate_setup_file(world: 'CivVIWorld') -> str:
+    """
+    Generates the Lua for the setup file. This sets initial variables and state that affect gameplay around Progressive Eras
+    """
+    setup = "-- Setup"
+    if world.options.progression_style == "eras_and_districts":
+        setup += f"""
+    -- Init Progressive Era Value if it hasn't been set already
+    if Game.GetProperty("MaxAllowedEra") == nil then
+      print("Setting MaxAllowedEra to 0")
+      Game.SetProperty("MaxAllowedEra", 0)
+    end
+    """
+
+    if world.options.boostsanity:
+        setup += f"""
+    -- Init Boosts
+    if Game.GetProperty("BoostsAsChecks") == nil then
+      print("Setting Boosts As Checks to True")
+      Game.SetProperty("BoostsAsChecks", true)
+    end
+    """
+    return setup
+
+
+def generate_goody_hut_sql(world: 'CivVIWorld') -> str:
+    """
+    Generates the SQL for the goody huts or an empty string if they are disabled since the mod expects the file to be there
+    """
+
+    if world.options.shuffle_goody_hut_rewards:
+        return f"""
+        UPDATE GoodyHutSubTypes SET Description = NULL WHERE GoodyHut NOT IN ('METEOR_GOODIES', 'GOODYHUT_SAILOR_WONDROUS', 'DUMMY_GOODY_BUILDIER') AND Weight > 0;
+
+INSERT INTO Modifiers
+                (ModifierId, ModifierType, RunOnce, Permanent, SubjectRequirementSetId)
+SELECT ModifierID||'_AI', ModifierType, RunOnce, Permanent, 'PLAYER_IS_AI'
+FROM Modifiers
+WHERE EXISTS (
+        SELECT ModifierId
+        FROM GoodyHutSubTypes
+        WHERE Modifiers.ModifierId = GoodyHutSubTypes.ModifierId AND GoodyHutSubTypes.GoodyHut NOT IN ('METEOR_GOODIES', 'GOODYHUT_SAILOR_WONDROUS', 'DUMMY_GOODY_BUILDIER') AND GoodyHutSubTypes.Weight > 0);
+
+INSERT INTO ModifierArguments
+                (ModifierId, Name, Type, Value)
+SELECT ModifierID||'_AI', Name, Type, Value
+FROM ModifierArguments
+WHERE EXISTS (
+        SELECT ModifierId
+        FROM GoodyHutSubTypes
+        WHERE ModifierArguments.ModifierId = GoodyHutSubTypes.ModifierId AND GoodyHutSubTypes.GoodyHut NOT IN ('METEOR_GOODIES', 'GOODYHUT_SAILOR_WONDROUS', 'DUMMY_GOODY_BUILDIER') AND GoodyHutSubTypes.Weight > 0);
+
+UPDATE GoodyHutSubTypes
+SET ModifierID = ModifierID||'_AI'
+WHERE GoodyHut NOT IN ('METEOR_GOODIES', 'GOODYHUT_SAILOR_WONDROUS', 'DUMMY_GOODY_BUILDIER') AND Weight > 0;
+
+      """
+    return "-- Goody Huts are disabled, no changes needed"
+
+
+def generate_update_boosts_sql(world: 'CivVIWorld') -> str:
+    """
+    Generates the SQL for existing boosts in boostsanity or an empty string if they are disabled since the mod expects the file to be there
+    """
+
+    if world.options.boostsanity:
+        return f"""
+UPDATE Boosts
+SET TechnologyType = 'BOOST_' || TechnologyType
+WHERE TechnologyType IS NOT NULL;
+UPDATE Boosts
+SET CivicType = 'BOOST_' || CivicType
+WHERE CivicType IS NOT NULL AND CivicType NOT IN ('CIVIC_CORPORATE_LIBERTARIANISM', 'CIVIC_DIGITAL_DEMOCRACY', 'CIVIC_SYNTHETIC_TECHNOCRACY', 'CIVIC_NEAR_FUTURE_GOVERNANCE');
+        """
+    return "-- Boostsanity is disabled, no changes needed"

worlds/civ_6/Data.py

@@ -0,0 +1,70 @@
+from typing import Dict, List
+
+from .ItemData import (
+    CivVIBoostData,
+    CivicPrereqData,
+    ExistingItemData,
+    GoodyHutRewardData,
+    NewItemData,
+    TechPrereqData,
+)
+
+
+def get_boosts_data() -> List[CivVIBoostData]:
+    from .data.boosts import boosts
+
+    return boosts
+
+
+def get_era_required_items_data() -> Dict[str, List[str]]:
+    from .data.era_required_items import era_required_items
+
+    return era_required_items
+
+
+def get_existing_civics_data() -> List[ExistingItemData]:
+    from .data.existing_civics import existing_civics
+
+    return existing_civics
+
+
+def get_existing_techs_data() -> List[ExistingItemData]:
+    from .data.existing_tech import existing_tech
+
+    return existing_tech
+
+
+def get_goody_hut_rewards_data() -> List[GoodyHutRewardData]:
+    from .data.goody_hut_rewards import reward_data
+
+    return reward_data
+
+
+def get_new_civic_prereqs_data() -> List[CivicPrereqData]:
+    from .data.new_civic_prereqs import new_civic_prereqs
+
+    return new_civic_prereqs
+
+
+def get_new_civics_data() -> List[NewItemData]:
+    from .data.new_civics import new_civics
+
+    return new_civics
+
+
+def get_new_tech_prereqs_data() -> List[TechPrereqData]:
+    from .data.new_tech_prereqs import new_tech_prereqs
+
+    return new_tech_prereqs
+
+
+def get_new_techs_data() -> List[NewItemData]:
+    from .data.new_tech import new_tech
+
+    return new_tech
+
+
+def get_progressive_districts_data() -> Dict[str, List[str]]:
+    from .data.progressive_districts import progressive_districts
+
+    return progressive_districts

worlds/civ_6/DeathLink.py

@@ -0,0 +1,74 @@
+import random
+
+from typing import TYPE_CHECKING, List
+if TYPE_CHECKING:
+    from .Civ6Client import CivVIContext
+
+# any is also an option but should not be considered an effect
+DEATH_LINK_EFFECTS = ["Gold", "Faith", "Era Score", "Unit Killed"]
+
+
+async def handle_receive_deathlink(ctx: 'CivVIContext', message: str):
+    """Resolves the effects of a deathlink received from the multiworld based on the options selected by the player"""
+    chosen_effects: List[str] = ctx.slot_data["death_link_effect"]
+    effect = random.choice(chosen_effects)
+
+    percent = ctx.slot_data["death_link_effect_percent"]
+    if effect == "Gold":
+        ctx.logger.info(f"Decreasing gold by {percent}%")
+        await ctx.game_interface.decrease_gold_by_percent(percent, message)
+    elif effect == "Faith":
+        ctx.logger.info(f"Decreasing faith by {percent}%")
+        await ctx.game_interface.decrease_faith_by_percent(percent, message)
+    elif effect == "Era Score":
+        ctx.logger.info("Decreasing era score by 1")
+        await ctx.game_interface.decrease_era_score_by_amount(1, message)
+    elif effect == "Unit Killed":
+        ctx.logger.info("Destroying a random unit")
+        await ctx.game_interface.kill_unit(message)
+
+
+async def handle_check_deathlink(ctx: 'CivVIContext'):
+    """Checks if the local player should send out a deathlink to the multiworld as well as if we should respond to any pending deathlinks sent to us """
+    # check if we received a death link
+    if ctx.received_death_link:
+        ctx.received_death_link = False
+        await handle_receive_deathlink(ctx, ctx.death_link_message)
+
+    # Check if we should send out a death link
+    result = await ctx.game_interface.get_deathlink()
+    if ctx.death_link_just_changed:
+        ctx.death_link_just_changed = False
+        return
+    if result != "false":
+        messages = [f"lost a unit to a {result}",
+                    f"offered a sacrifice to the great {result}",
+                    f"was killed by a {result}",
+                    f"made a donation to the {result} fund",
+                    f"made a tactical error",
+                    f"picked a fight with a {result} and lost",
+                    f"tried to befriend an enemy {result}",
+                    f"used a {result} to reduce their military spend",
+                    f"was defeated by a {result} in combat",
+                    f"bravely struck a {result} and paid the price",
+                    f"had a lapse in judgement against a {result}",
+                    f"learned at the hands of a {result}",
+                    f"attempted to non peacefully negotiate with a {result}",
+                    f"was outsmarted by a {result}",
+                    f"received a lesson from a {result}",
+                    f"now understands the importance of not fighting a {result}",
+                    f"let a {result} get the better of them",
+                    f"allowed a {result} to show them the error of their ways",
+                    f"heard the tragedy of Darth Plagueis the Wise from a {result}",
+                    f"refused to join a {result} in their quest for power",
+                    f"was tired of sitting in BK and decided to fight a {result} instead",
+                    f"purposely lost to a {result} as a cry for help",
+                    f"is wanting to remind everyone that they are here to have fun and not to win",
+                    f"is reconsidering their pursuit of a domination victory",
+                    f"had their plans toppled by a {result}",
+                    ]
+
+        if ctx.slot is not None:
+            player = ctx.player_names[ctx.slot]
+            message = random.choice(messages)
+            await ctx.send_death(f"{player} {message}")

worlds/civ_6/Enum.py

@@ -0,0 +1,39 @@
+from enum import Enum
+
+from BaseClasses import ItemClassification
+
+
+class EraType(Enum):
+    ERA_ANCIENT = "ERA_ANCIENT"
+    ERA_CLASSICAL = "ERA_CLASSICAL"
+    ERA_MEDIEVAL = "ERA_MEDIEVAL"
+    ERA_RENAISSANCE = "ERA_RENAISSANCE"
+    ERA_INDUSTRIAL = "ERA_INDUSTRIAL"
+    ERA_MODERN = "ERA_MODERN"
+    ERA_ATOMIC = "ERA_ATOMIC"
+    ERA_INFORMATION = "ERA_INFORMATION"
+    ERA_FUTURE = "ERA_FUTURE"
+
+
+class CivVICheckType(Enum):
+    TECH = "TECH"
+    CIVIC = "CIVIC"
+    PROGRESSIVE_DISTRICT = "PROGRESSIVE_DISTRICT"
+    ERA = "ERA"
+    GOODY = "GOODY"
+    BOOST = "BOOST"
+    EVENT = "EVENT"
+
+class CivVIHintClassification(Enum):
+    PROGRESSION = "Progression"
+    USEFUL = "Useful"
+    FILLER = "Filler"
+
+    def to_item_classification(self) -> ItemClassification:
+        if self == CivVIHintClassification.PROGRESSION:
+            return ItemClassification.progression
+        if self == CivVIHintClassification.USEFUL:
+            return ItemClassification.useful
+        if self == CivVIHintClassification.FILLER:
+            return ItemClassification.filler
+        assert False

worlds/civ_6/ItemData.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+from typing import List, TypedDict
+
+
+class NewItemData(TypedDict):
+    Type: str
+    Cost: int
+    UITreeRow: int
+    EraType: str
+
+
+class ExistingItemData(NewItemData):
+    Name: str
+
+
+@dataclass
+class CivVIBoostData:
+    Type: str
+    EraType: str
+    Prereq: List[str]
+    PrereqRequiredCount: int
+    Classification: str
+
+
+class GoodyHutRewardData(TypedDict):
+    Type: str
+    Name: str
+    Rarity: str
+
+
+class CivicPrereqData(TypedDict):
+    Civic: str
+    PrereqTech: str
+
+
+class TechPrereqData(TypedDict):
+    Technology: str
+    PrereqTech: str

worlds/civ_6/Items.py

@@ -0,0 +1,353 @@
+from enum import Enum
+from typing import Dict, Optional, TYPE_CHECKING, List
+from BaseClasses import Item, ItemClassification
+from .Data import (
+    GoodyHutRewardData,
+    get_era_required_items_data,
+    get_existing_civics_data,
+    get_existing_techs_data,
+    get_goody_hut_rewards_data,
+    get_progressive_districts_data,
+)
+from .Enum import CivVICheckType, EraType
+from .ProgressiveDistricts import get_flat_progressive_districts
+
+if TYPE_CHECKING:
+    from . import CivVIWorld
+
+
+CIV_VI_AP_ITEM_ID_BASE = 5041000
+
+NON_PROGRESSION_DISTRICTS = ["PROGRESSIVE_PRESERVE", "PROGRESSIVE_NEIGHBORHOOD"]
+
+
+# Items required as progression for boostsanity mode
+BOOSTSANITY_PROGRESSION_ITEMS = [
+    "TECH_THE_WHEEL",
+    "TECH_MASONRY",
+    "TECH_ARCHERY",
+    "TECH_ENGINEERING",
+    "TECH_CONSTRUCTION",
+    "TECH_GUNPOWDER",
+    "TECH_MACHINERY",
+    "TECH_SIEGE_TACTICS",
+    "TECH_STIRRUPS",
+    "TECH_ASTRONOMY",
+    "TECH_BALLISTICS",
+    "TECH_STEAM_POWER",
+    "TECH_SANITATION",
+    "TECH_COMPUTERS",
+    "TECH_COMBUSTION",
+    "TECH_TELECOMMUNICATIONS",
+    "TECH_ROBOTICS",
+    "CIVIC_FEUDALISM",
+    "CIVIC_GUILDS",
+    "CIVIC_THE_ENLIGHTENMENT",
+    "CIVIC_MERCANTILISM",
+    "CIVIC_CONSERVATION",
+    "CIVIC_CIVIL_SERVICE",
+    "CIVIC_GLOBALIZATION",
+    "CIVIC_COLD_WAR",
+    "CIVIC_URBANIZATION",
+    "CIVIC_NATIONALISM",
+    "CIVIC_MOBILIZATION",
+    "PROGRESSIVE_NEIGHBORHOOD",
+    "PROGRESSIVE_PRESERVE",
+]
+
+
+class FillerItemRarity(Enum):
+    COMMON = "COMMON"
+    UNCOMMON = "UNCOMMON"
+    RARE = "RARE"
+
+
+FILLER_DISTRIBUTION: Dict[FillerItemRarity, float] = {
+    FillerItemRarity.RARE: 0.025,
+    FillerItemRarity.UNCOMMON: 0.2,
+    FillerItemRarity.COMMON: 0.775,
+}
+
+
+class FillerItemData:
+    name: str
+    type: str
+    rarity: FillerItemRarity
+    civ_name: str
+
+    def __init__(self, data: GoodyHutRewardData):
+        self.name = data["Name"]
+        self.rarity = FillerItemRarity(data["Rarity"])
+        self.civ_name = data["Type"]
+
+
+filler_data: Dict[str, FillerItemData] = {
+    item["Name"]: FillerItemData(item) for item in get_goody_hut_rewards_data()
+}
+
+
+class CivVIItemData:
+    civ_vi_id: int
+    classification: ItemClassification
+    name: str
+    code: int
+    cost: int
+    item_type: CivVICheckType
+    progressive_name: Optional[str]
+    civ_name: Optional[str]
+    era: Optional[EraType]
+
+    def __init__(
+        self,
+        name: str,
+        civ_vi_id: int,
+        cost: int,
+        item_type: CivVICheckType,
+        id_offset: int,
+        classification: ItemClassification,
+        progressive_name: Optional[str],
+        civ_name: Optional[str] = None,
+        era: Optional[EraType] = None,
+    ):
+        self.classification = classification
+        self.civ_vi_id = civ_vi_id
+        self.name = name
+        self.code = civ_vi_id + CIV_VI_AP_ITEM_ID_BASE + id_offset
+        self.cost = cost
+        self.item_type = item_type
+        self.progressive_name = progressive_name
+        self.civ_name = civ_name
+        self.era = era
+
+
+class CivVIEvent(Item):
+    game: str = "Civilization VI"
+
+
+class CivVIItem(Item):
+    game: str = "Civilization VI"
+    civ_vi_id: int
+    item_type: CivVICheckType
+
+    def __init__(
+        self,
+        item: CivVIItemData,
+        player: int,
+        classification: Optional[ItemClassification] = None,
+    ):
+        super().__init__(
+            item.name, classification or item.classification, item.code, player
+        )
+        self.civ_vi_id = item.civ_vi_id
+        self.item_type = item.item_type
+
+
+def format_item_name(name: str) -> str:
+    name_parts = name.split("_")
+    return " ".join([part.capitalize() for part in name_parts])
+
+
+_items_by_civ_name: Dict[str, CivVIItemData] = {}
+
+
+def get_item_by_civ_name(
+    item_name: str, item_table: Dict[str, "CivVIItemData"]
+) -> "CivVIItemData":
+    """Gets the names of the items in the item_table"""
+    if not _items_by_civ_name:
+        for item in item_table.values():
+            if item.civ_name:
+                _items_by_civ_name[item.civ_name] = item
+
+    try:
+        return _items_by_civ_name[item_name]
+    except KeyError as e:
+        raise KeyError(f"Item {item_name} not found in item_table") from e
+
+
+def _generate_tech_items(
+    id_base: int, required_items: List[str], progressive_items: Dict[str, str]
+) -> Dict[str, CivVIItemData]:
+    # Generate Techs
+    existing_techs = get_existing_techs_data()
+    tech_table: Dict[str, CivVIItemData] = {}
+
+    tech_id = 0
+    for tech in existing_techs:
+        classification = ItemClassification.useful
+        name = tech["Name"]
+        civ_name = tech["Type"]
+        if civ_name in required_items:
+            classification = ItemClassification.progression
+        progressive_name = None
+        check_type = CivVICheckType.TECH
+        if civ_name in progressive_items.keys():
+            progressive_name = format_item_name(progressive_items[civ_name])
+
+        tech_table[name] = CivVIItemData(
+            name=name,
+            civ_vi_id=tech_id,
+            cost=tech["Cost"],
+            item_type=check_type,
+            id_offset=id_base,
+            classification=classification,
+            progressive_name=progressive_name,
+            civ_name=civ_name,
+            era=EraType(tech["EraType"]),
+        )
+
+        tech_id += 1
+
+    return tech_table
+
+
+def _generate_civics_items(
+    id_base: int, required_items: List[str], progressive_items: Dict[str, str]
+) -> Dict[str, CivVIItemData]:
+    civic_id = 0
+    civic_table: Dict[str, CivVIItemData] = {}
+    existing_civics = get_existing_civics_data()
+
+    for civic in existing_civics:
+        name = civic["Name"]
+        civ_name = civic["Type"]
+        progressive_name = None
+        check_type = CivVICheckType.CIVIC
+
+        if civ_name in progressive_items.keys():
+            progressive_name = format_item_name(progressive_items[civ_name])
+
+        classification = ItemClassification.useful
+        if civ_name in required_items:
+            classification = ItemClassification.progression
+
+        civic_table[name] = CivVIItemData(
+            name=name,
+            civ_vi_id=civic_id,
+            cost=civic["Cost"],
+            item_type=check_type,
+            id_offset=id_base,
+            classification=classification,
+            progressive_name=progressive_name,
+            civ_name=civ_name,
+            era=EraType(civic["EraType"]),
+        )
+
+        civic_id += 1
+
+    return civic_table
+
+
+def _generate_progressive_district_items(id_base: int) -> Dict[str, CivVIItemData]:
+    progressive_table: Dict[str, CivVIItemData] = {}
+    progressive_id_base = 0
+    progressive_items = get_progressive_districts_data()
+    for item_name in progressive_items.keys():
+        classification = (
+            ItemClassification.useful
+            if item_name in NON_PROGRESSION_DISTRICTS
+            else ItemClassification.progression
+        )
+        name = format_item_name(item_name)
+        progressive_table[name] = CivVIItemData(
+            name=name,
+            civ_vi_id=progressive_id_base,
+            cost=0,
+            item_type=CivVICheckType.PROGRESSIVE_DISTRICT,
+            id_offset=id_base,
+            classification=classification,
+            progressive_name=None,
+            civ_name=item_name,
+        )
+        progressive_id_base += 1
+    return progressive_table
+
+
+def _generate_progressive_era_items(id_base: int) -> Dict[str, CivVIItemData]:
+    """Generates the single progressive district item"""
+    era_table: Dict[str, CivVIItemData] = {}
+    # Generate progressive eras
+    progressive_era_name = format_item_name("PROGRESSIVE_ERA")
+    era_table[progressive_era_name] = CivVIItemData(
+        name=progressive_era_name,
+        civ_vi_id=0,
+        cost=0,
+        item_type=CivVICheckType.ERA,
+        id_offset=id_base,
+        classification=ItemClassification.progression,
+        progressive_name=None,
+        civ_name="PROGRESSIVE_ERA",
+    )
+    return era_table
+
+
+def _generate_goody_hut_items(id_base: int) -> Dict[str, CivVIItemData]:
+    # Generate goody hut items
+    goody_huts = {
+        item["Name"]: FillerItemData(item) for item in get_goody_hut_rewards_data()
+    }
+    goody_table: Dict[str, CivVIItemData] = {}
+    goody_base = 0
+    for value in goody_huts.values():
+        goody_table[value.name] = CivVIItemData(
+            name=value.name,
+            civ_vi_id=goody_base,
+            cost=0,
+            item_type=CivVICheckType.GOODY,
+            id_offset=id_base,
+            classification=ItemClassification.filler,
+            progressive_name=None,
+            civ_name=value.civ_name,
+        )
+        goody_base += 1
+    return goody_table
+
+
+def generate_item_table() -> Dict[str, CivVIItemData]:
+    era_required_items = get_era_required_items_data()
+    required_items: List[str] = []
+    for value in era_required_items.values():
+        required_items += value
+
+    progressive_items = get_flat_progressive_districts()
+
+    item_table: Dict[str, CivVIItemData] = {}
+
+    def get_id_base():
+        return len(item_table.keys())
+
+    item_table.update(
+        **_generate_tech_items(get_id_base(), required_items, progressive_items)
+    )
+    item_table.update(
+        **_generate_civics_items(get_id_base(), required_items, progressive_items)
+    )
+    item_table.update(**_generate_progressive_district_items(get_id_base()))
+    item_table.update(**_generate_progressive_era_items(get_id_base()))
+    item_table.update(**_generate_goody_hut_items(get_id_base()))
+
+    return item_table
+
+
+def get_items_by_type(
+    item_type: CivVICheckType, item_table: Dict[str, CivVIItemData]
+) -> List[CivVIItemData]:
+    """
+    Returns a list of items that match the given item type
+    """
+    return [item for item in item_table.values() if item.item_type == item_type]
+
+
+fillers_by_rarity: Dict[FillerItemRarity, List[FillerItemData]] = {
+    rarity: [item for item in filler_data.values() if item.rarity == rarity]
+    for rarity in FillerItemRarity
+}
+
+
+def get_random_filler_by_rarity(
+    world: "CivVIWorld", rarity: FillerItemRarity
+) -> FillerItemData:
+    """
+    Returns a random filler item by rarity
+    """
+    return world.random.choice(fillers_by_rarity[rarity])