Factorio: Add an Allow Collect Option

.coveragerc

@@ -1,5 +0,0 @@
-[report]
-exclude_lines = 
-    pragma: no cover
-    if TYPE_CHECKING:
-    if typing.TYPE_CHECKING:

.github/workflows/analyze-modified-files.yml

@@ -71,7 +71,7 @@ jobs:
         continue-on-error: true
         if: env.diff != '' && matrix.task == 'flake8'
         run: |
-          flake8 --count --max-complexity=14 --max-doc-length=120 --max-line-length=120 --statistics ${{ env.diff }}
+          flake8 --count --max-complexity=10 --max-doc-length=120 --max-line-length=120 --statistics ${{ env.diff }}
 
       - name: "mypy: Type check modified files"
         continue-on-error: true

.run/Archipelago Unittests.run.xml

@@ -1,18 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Archipelago Unittests" type="tests" factoryName="Unittests">
-    <module name="Archipelago" />
-    <option name="INTERPRETER_OPTIONS" value="" />
-    <option name="PARENT_ENVS" value="true" />
-    <option name="SDK_HOME" value="" />
-    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
-    <option name="IS_MODULE_SDK" value="true" />
-    <option name="ADD_CONTENT_ROOTS" value="true" />
-    <option name="ADD_SOURCE_ROOTS" value="true" />
-    <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
-    <option name="_new_pattern" value="&quot;&quot;" />
-    <option name="_new_additionalArguments" value="&quot;&quot;" />
-    <option name="_new_target" value="&quot;$PROJECT_DIR$/test&quot;" />
-    <option name="_new_targetType" value="&quot;PATH&quot;" />
-    <method v="2" />
-  </configuration>
-</component>

AdventureClient.py

@@ -115,12 +115,11 @@ class AdventureContext(CommonContext):
             msg = f"Received {', '.join([self.item_names[item.item] for item in args['items']])}"
             self._set_message(msg, SYSTEM_MESSAGE_ID)
         elif cmd == "Retrieved":
-            if f"adventure_{self.auth}_freeincarnates_used" in args["keys"]:
-                self.freeincarnates_used = args["keys"][f"adventure_{self.auth}_freeincarnates_used"]
-                if self.freeincarnates_used is None:
-                    self.freeincarnates_used = 0
-                self.freeincarnates_used += self.freeincarnate_pending
-                self.send_pending_freeincarnates()
+            self.freeincarnates_used = args["keys"][f"adventure_{self.auth}_freeincarnates_used"]
+            if self.freeincarnates_used is None:
+                self.freeincarnates_used = 0
+            self.freeincarnates_used += self.freeincarnate_pending
+            self.send_pending_freeincarnates()
         elif cmd == "SetReply":
             if args["key"] == f"adventure_{self.auth}_freeincarnates_used":
                 self.freeincarnates_used = args["value"]

BaseClasses.py

@@ -252,20 +252,15 @@ class MultiWorld():
                                  range(1, self.players + 1)}
 
     def set_options(self, args: Namespace) -> None:
-        # TODO - remove this section once all worlds use options dataclasses
-        all_keys: Set[str] = {key for player in self.player_ids for key in
-                              AutoWorld.AutoWorldRegister.world_types[self.game[player]].options_dataclass.type_hints}
-        for option_key in all_keys:
-            option = Utils.DeprecateDict(f"Getting options from multiworld is now deprecated. "
-                                         f"Please use `self.options.{option_key}` instead.")
-            option.update(getattr(args, option_key, {}))
-            setattr(self, option_key, option)
-
         for player in self.player_ids:
             world_type = AutoWorld.AutoWorldRegister.world_types[self.game[player]]
             self.worlds[player] = world_type(self, player)
             self.worlds[player].random = self.per_slot_randoms[player]
-            options_dataclass: typing.Type[Options.PerGameCommonOptions] = world_type.options_dataclass
+            for option_key in world_type.options_dataclass.type_hints:
+                option_values = getattr(args, option_key, {})
+                setattr(self, option_key, option_values)
+                # TODO - remove this loop once all worlds use options dataclasses
+            options_dataclass: typing.Type[Options.PerGameCommonOptions] = self.worlds[player].options_dataclass
             self.worlds[player].options = options_dataclass(**{option_key: getattr(args, option_key)[player]
                                                                for option_key in options_dataclass.type_hints})
 
@@ -496,7 +491,7 @@ class MultiWorld():
         else:
             return all((self.has_beaten_game(state, p) for p in range(1, self.players + 1)))
 
-    def can_beat_game(self, starting_state: Optional[CollectionState] = None) -> bool:
+    def can_beat_game(self, starting_state: Optional[CollectionState] = None):
         if starting_state:
             if self.has_beaten_game(starting_state):
                 return True
@@ -509,7 +504,7 @@ class MultiWorld():
                           and location.item.advancement and location not in state.locations_checked}
 
         while prog_locations:
-            sphere: Set[Location] = set()
+            sphere = set()
             # build up spheres of collection radius.
             # Everything in each sphere is independent from each other in dependencies and only depends on lower spheres
             for location in prog_locations:
@@ -529,19 +524,12 @@ class MultiWorld():
 
         return False
 
-    def get_spheres(self) -> Iterator[Set[Location]]:
-        """
-        yields a set of locations for each logical sphere
-
-        If there are unreachable locations, the last sphere of reachable
-        locations is followed by an empty set, and then a set of all of the
-        unreachable locations.
-        """
+    def get_spheres(self):
         state = CollectionState(self)
         locations = set(self.get_filled_locations())
 
         while locations:
-            sphere: Set[Location] = set()
+            sphere = set()
 
             for location in locations:
                 if location.can_reach(state):
@@ -651,34 +639,34 @@ class CollectionState():
 
     def update_reachable_regions(self, player: int):
         self.stale[player] = False
-        reachable_regions = self.reachable_regions[player]
-        blocked_connections = self.blocked_connections[player]
+        rrp = self.reachable_regions[player]
+        bc = self.blocked_connections[player]
         queue = deque(self.blocked_connections[player])
-        start = self.multiworld.get_region("Menu", player)
+        start = self.multiworld.get_region('Menu', player)
 
         # init on first call - this can't be done on construction since the regions don't exist yet
-        if start not in reachable_regions:
-            reachable_regions.add(start)
-            blocked_connections.update(start.exits)
+        if start not in rrp:
+            rrp.add(start)
+            bc.update(start.exits)
             queue.extend(start.exits)
 
         # run BFS on all connections, and keep track of those blocked by missing items
         while queue:
             connection = queue.popleft()
             new_region = connection.connected_region
-            if new_region in reachable_regions:
-                blocked_connections.remove(connection)
+            if new_region in rrp:
+                bc.remove(connection)
             elif connection.can_reach(self):
                 assert new_region, f"tried to search through an Entrance \"{connection}\" with no Region"
-                reachable_regions.add(new_region)
-                blocked_connections.remove(connection)
-                blocked_connections.update(new_region.exits)
+                rrp.add(new_region)
+                bc.remove(connection)
+                bc.update(new_region.exits)
                 queue.extend(new_region.exits)
                 self.path[new_region] = (new_region.name, self.path.get(connection, None))
 
                 # Retry connections if the new region can unblock them
                 for new_entrance in self.multiworld.indirect_connections.get(new_region, set()):
-                    if new_entrance in blocked_connections and new_entrance not in queue:
+                    if new_entrance in bc and new_entrance not in queue:
                         queue.append(new_entrance)
 
     def copy(self) -> CollectionState:
@@ -1056,6 +1044,9 @@ class Location:
 
     @property
     def hint_text(self) -> str:
+        hint_text = getattr(self, "_hint_text", None)
+        if hint_text:
+            return hint_text
         return "at " + self.name.replace("_", " ").replace("-", " ")
 
 

CommonClient.py

@@ -460,7 +460,7 @@ class CommonContext:
                 else:
                     self.update_game(cached_game)
         if needed_updates:
-            await self.send_msgs([{"cmd": "GetDataPackage", "games": [game_name]} for game_name in needed_updates])
+            await self.send_msgs([{"cmd": "GetDataPackage", "games": list(needed_updates)}])
 
     def update_game(self, game_package: dict):
         for item_name, item_id in game_package["item_name_to_id"].items():
@@ -477,7 +477,6 @@ class CommonContext:
         current_cache = Utils.persistent_load().get("datapackage", {}).get("games", {})
         current_cache.update(data_package["games"])
         Utils.persistent_store("datapackage", "games", current_cache)
-        logger.info(f"Got new ID/Name DataPackage for {', '.join(data_package['games'])}")
         for game, game_data in data_package["games"].items():
             Utils.store_data_package_for_checksum(game, game_data)
 
@@ -612,10 +611,6 @@ async def server_loop(ctx: CommonContext, address: typing.Optional[str] = None)
 
     address = f"ws://{address}" if "://" not in address \
         else address.replace("archipelago://", "ws://")
-    uri = urllib.parse.urlparse(address)
-    if uri.username and uri.password is None:
-        # Fix for Firefox stripping empty password https://bugzilla.mozilla.org/show_bug.cgi?id=1876952
-        address = address.replace("@", ":@")
 
     server_url = urllib.parse.urlparse(address)
     if server_url.username:
@@ -732,6 +727,7 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
             await ctx.server_auth(args['password'])
 
     elif cmd == 'DataPackage':
+        logger.info("Got new ID/Name DataPackage")
         ctx.consume_network_data_package(args['data'])
 
     elif cmd == 'ConnectionRefused':

Fill.py

@@ -550,7 +550,7 @@ def flood_items(world: MultiWorld) -> None:
                 break
 
 
-def balance_multiworld_progression(multiworld: MultiWorld) -> None:
+def balance_multiworld_progression(world: MultiWorld) -> None:
     # A system to reduce situations where players have no checks remaining, popularly known as "BK mode."
     # Overall progression balancing algorithm:
     # Gather up all locations in a sphere.
@@ -558,28 +558,28 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
     # If other players are below the threshold value, swap progression in this sphere into earlier spheres,
     #   which gives more locations available by this sphere.
     balanceable_players: typing.Dict[int, float] = {
-        player: multiworld.worlds[player].options.progression_balancing / 100
-        for player in multiworld.player_ids
-        if multiworld.worlds[player].options.progression_balancing > 0
+        player: world.worlds[player].options.progression_balancing / 100
+        for player in world.player_ids
+        if world.worlds[player].options.progression_balancing > 0
     }
     if not balanceable_players:
         logging.info('Skipping multiworld progression balancing.')
     else:
         logging.info(f'Balancing multiworld progression for {len(balanceable_players)} Players.')
         logging.debug(balanceable_players)
-        state: CollectionState = CollectionState(multiworld)
+        state: CollectionState = CollectionState(world)
         checked_locations: typing.Set[Location] = set()
-        unchecked_locations: typing.Set[Location] = set(multiworld.get_locations())
+        unchecked_locations: typing.Set[Location] = set(world.get_locations())
 
         total_locations_count: typing.Counter[int] = Counter(
             location.player
-            for location in multiworld.get_locations()
+            for location in world.get_locations()
             if not location.locked
         )
         reachable_locations_count: typing.Dict[int, int] = {
             player: 0
-            for player in multiworld.player_ids
-            if total_locations_count[player] and len(multiworld.get_filled_locations(player)) != 0
+            for player in world.player_ids
+            if total_locations_count[player] and len(world.get_filled_locations(player)) != 0
         }
         balanceable_players = {
             player: balanceable_players[player]
@@ -658,7 +658,7 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
                             balancing_unchecked_locations.remove(location)
                             if not location.locked:
                                 balancing_reachables[location.player] += 1
-                        if multiworld.has_beaten_game(balancing_state) or all(
+                        if world.has_beaten_game(balancing_state) or all(
                                 item_percentage(player, reachables) >= threshold_percentages[player]
                                 for player, reachables in balancing_reachables.items()
                                 if player in threshold_percentages):
@@ -675,7 +675,7 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
                         locations_to_test = unlocked_locations[player]
                         items_to_test = list(candidate_items[player])
                         items_to_test.sort()
-                        multiworld.random.shuffle(items_to_test)
+                        world.random.shuffle(items_to_test)
                         while items_to_test:
                             testing = items_to_test.pop()
                             reducing_state = state.copy()
@@ -687,8 +687,8 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
 
                             reducing_state.sweep_for_events(locations=locations_to_test)
 
-                            if multiworld.has_beaten_game(balancing_state):
-                                if not multiworld.has_beaten_game(reducing_state):
+                            if world.has_beaten_game(balancing_state):
+                                if not world.has_beaten_game(reducing_state):
                                     items_to_replace.append(testing)
                             else:
                                 reduced_sphere = get_sphere_locations(reducing_state, locations_to_test)
@@ -696,32 +696,33 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
                                 if p < threshold_percentages[player]:
                                     items_to_replace.append(testing)
 
-                    old_moved_item_count = moved_item_count
+                    replaced_items = False
 
                     # sort then shuffle to maintain deterministic behaviour,
                     # while allowing use of set for better algorithm growth behaviour elsewhere
                     replacement_locations = sorted(l for l in checked_locations if not l.event and not l.locked)
-                    multiworld.random.shuffle(replacement_locations)
+                    world.random.shuffle(replacement_locations)
                     items_to_replace.sort()
-                    multiworld.random.shuffle(items_to_replace)
+                    world.random.shuffle(items_to_replace)
 
                     # Start swapping items. Since we swap into earlier spheres, no need for accessibility checks. 
                     while replacement_locations and items_to_replace:
                         old_location = items_to_replace.pop()
-                        for i, new_location in enumerate(replacement_locations):
+                        for new_location in replacement_locations:
                             if new_location.can_fill(state, old_location.item, False) and \
                                     old_location.can_fill(state, new_location.item, False):
-                                replacement_locations.pop(i)
+                                replacement_locations.remove(new_location)
                                 swap_location_item(old_location, new_location)
                                 logging.debug(f"Progression balancing moved {new_location.item} to {new_location}, "
                                               f"displacing {old_location.item} into {old_location}")
                                 moved_item_count += 1
                                 state.collect(new_location.item, True, new_location)
+                                replaced_items = True
                                 break
                         else:
                             logging.warning(f"Could not Progression Balance {old_location.item}")
 
-                    if old_moved_item_count < moved_item_count:
+                    if replaced_items:
                         logging.debug(f"Moved {moved_item_count} items so far\n")
                         unlocked = {fresh for player in balancing_players for fresh in unlocked_locations[player]}
                         for location in get_sphere_locations(state, unlocked):
@@ -735,7 +736,7 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
                     state.collect(location.item, True, location)
             checked_locations |= sphere_locations
 
-            if multiworld.has_beaten_game(state):
+            if world.has_beaten_game(state):
                 break
             elif not sphere_locations:
                 logging.warning("Progression Balancing ran out of paths.")

Main.py

@@ -114,22 +114,9 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
             for _ in range(count):
                 world.push_precollected(world.create_item(item_name, player))
 
-        for item_name, count in getattr(world.worlds[player].options,
-                                        "start_inventory_from_pool",
-                                        StartInventoryPool({})).value.items():
+        for item_name, count in world.start_inventory_from_pool.setdefault(player, StartInventoryPool({})).value.items():
             for _ in range(count):
                 world.push_precollected(world.create_item(item_name, player))
-            # remove from_pool items also from early items handling, as starting is plenty early.
-            early = world.early_items[player].get(item_name, 0)
-            if early:
-                world.early_items[player][item_name] = max(0, early-count)
-                remaining_count = count-early
-                if remaining_count > 0:
-                    local_early = world.early_local_items[player].get(item_name, 0)
-                    if local_early:
-                        world.early_items[player][item_name] = max(0, local_early - remaining_count)
-                    del local_early
-            del early
 
     logger.info('Creating World.')
     AutoWorld.call_all(world, "create_regions")
@@ -169,14 +156,10 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
 
     # remove starting inventory from pool items.
     # Because some worlds don't actually create items during create_items this has to be as late as possible.
-    if any(getattr(world.worlds[player].options, "start_inventory_from_pool", None) for player in world.player_ids):
+    if any(world.start_inventory_from_pool[player].value for player in world.player_ids):
         new_items: List[Item] = []
         depletion_pool: Dict[int, Dict[str, int]] = {
-            player: getattr(world.worlds[player].options,
-                            "start_inventory_from_pool",
-                            StartInventoryPool({})).value.copy()
-            for player in world.player_ids
-        }
+            player: world.start_inventory_from_pool[player].value.copy() for player in world.player_ids}
         for player, items in depletion_pool.items():
             player_world: AutoWorld.World = world.worlds[player]
             for count in items.values():

ModuleUpdate.py

@@ -4,29 +4,14 @@ import subprocess
 import multiprocessing
 import warnings
 
+local_dir = os.path.dirname(__file__)
+requirements_files = {os.path.join(local_dir, 'requirements.txt')}
 
 if sys.version_info < (3, 8, 6):
     raise RuntimeError("Incompatible Python Version. 3.8.7+ is supported.")
 
 # don't run update if environment is frozen/compiled or if not the parent process (skip in subprocess)
-_skip_update = bool(getattr(sys, "frozen", False) or multiprocessing.parent_process())
-update_ran = _skip_update
-
-
-class RequirementsSet(set):
-    def add(self, e):
-        global update_ran
-        update_ran &= _skip_update
-        super().add(e)
-
-    def update(self, *s):
-        global update_ran
-        update_ran &= _skip_update
-        super().update(*s)
-
-
-local_dir = os.path.dirname(__file__)
-requirements_files = RequirementsSet((os.path.join(local_dir, 'requirements.txt'),))
+update_ran = getattr(sys, "frozen", False) or multiprocessing.parent_process()
 
 if not update_ran:
     for entry in os.scandir(os.path.join(local_dir, "worlds")):

MultiServer.py

@@ -2210,24 +2210,25 @@ def parse_args() -> argparse.Namespace:
 
 async def auto_shutdown(ctx, to_cancel=None):
     await asyncio.sleep(ctx.auto_shutdown)
-
-    def inactivity_shutdown():
-        ctx.server.ws_server.close()
-        ctx.exit_event.set()
-        if to_cancel:
-            for task in to_cancel:
-                task.cancel()
-        logging.info("Shutting down due to inactivity.")
-
     while not ctx.exit_event.is_set():
         if not ctx.client_activity_timers.values():
-            inactivity_shutdown()
+            ctx.server.ws_server.close()
+            ctx.exit_event.set()
+            if to_cancel:
+                for task in to_cancel:
+                    task.cancel()
+            logging.info("Shutting down due to inactivity.")
         else:
             newest_activity = max(ctx.client_activity_timers.values())
             delta = datetime.datetime.now(datetime.timezone.utc) - newest_activity
             seconds = ctx.auto_shutdown - delta.total_seconds()
             if seconds < 0:
-                inactivity_shutdown()
+                ctx.server.ws_server.close()
+                ctx.exit_event.set()
+                if to_cancel:
+                    for task in to_cancel:
+                        task.cancel()
+                logging.info("Shutting down due to inactivity.")
             else:
                 await asyncio.sleep(seconds)
 

Options.py

@@ -1033,6 +1033,11 @@ class DeathLink(Toggle):
     display_name = "Death Link"
 
 
+class AllowCollect(DefaultOnToggle):
+    """Allows checks in your world to be automatically marked as collected when !collect is run."""
+    display_name = "Allow Collect"
+
+
 class ItemLinks(OptionList):
     """Share part of your item pool with other players."""
     display_name = "Item Links"

README.md

@@ -58,7 +58,6 @@ Currently, the following games are supported:
 * Heretic
 * Landstalker: The Treasures of King Nole
 * Final Fantasy Mystic Quest
-* TUNIC
 
 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

Utils.py

@@ -779,25 +779,6 @@ def deprecate(message: str):
     import warnings
     warnings.warn(message)
 
-
-class DeprecateDict(dict):
-    log_message: str
-    should_error: bool
-
-    def __init__(self, message, error: bool = False) -> None:
-        self.log_message = message
-        self.should_error = error
-        super().__init__()
-
-    def __getitem__(self, item: Any) -> Any:
-        if self.should_error:
-            deprecate(self.log_message)
-        elif __debug__:
-            import warnings
-            warnings.warn(self.log_message)
-        return super().__getitem__(item)
-
-
 def _extend_freeze_support() -> None:
     """Extend multiprocessing.freeze_support() to also work on Non-Windows for spawn."""
     # upstream issue: https://github.com/python/cpython/issues/76327

WebHostLib/api/generate.py

@@ -20,8 +20,8 @@ def generate_api():
         race = False
         meta_options_source = {}
         if 'file' in request.files:
-            files = request.files.getlist('file')
-            options = get_yaml_data(files)
+            file = request.files['file']
+            options = get_yaml_data(file)
             if isinstance(options, Markup):
                 return {"text": options.striptags()}, 400
             if isinstance(options, str):

WebHostLib/check.py

@@ -1,4 +1,3 @@
-import os
 import zipfile
 import base64
 from typing import Union, Dict, Set, Tuple
@@ -7,7 +6,13 @@ from flask import request, flash, redirect, url_for, render_template
 from markupsafe import Markup
 
 from WebHostLib import app
-from WebHostLib.upload import allowed_options, allowed_options_extensions, banned_file
+
+banned_zip_contents = (".sfc",)
+
+
+def allowed_file(filename):
+    return filename.endswith(('.txt', ".yaml", ".zip"))
+
 
 from Generate import roll_settings, PlandoOptions
 from Utils import parse_yamls
@@ -46,41 +51,33 @@ def mysterycheck():
 def get_yaml_data(files) -> Union[Dict[str, str], str, Markup]:
     options = {}
     for uploaded_file in files:
-        if banned_file(uploaded_file.filename):
-            return ("Uploaded data contained a rom file, which is likely to contain copyrighted material. "
-                    "Your file was deleted.")
-        # If the user does not select file, the browser will still submit an empty string without a file name.
-        elif uploaded_file.filename == "":
-            return "No selected file."
+        # if user does not select file, browser also
+        # submit an empty part without filename
+        if uploaded_file.filename == '':
+            return 'No selected file'
         elif uploaded_file.filename in options:
-            return f"Conflicting files named {uploaded_file.filename} submitted."
-        elif uploaded_file and allowed_options(uploaded_file.filename):
+            return f'Conflicting files named {uploaded_file.filename} submitted'
+        elif uploaded_file and allowed_file(uploaded_file.filename):
             if uploaded_file.filename.endswith(".zip"):
-                if not zipfile.is_zipfile(uploaded_file):
-                    return f"Uploaded file {uploaded_file.filename} is not a valid .zip file and cannot be opened."
 
-                uploaded_file.seek(0)  # offset from is_zipfile check
-                with zipfile.ZipFile(uploaded_file, "r") as zfile:
-                    for file in zfile.infolist():
-                        # Remove folder pathing from str (e.g. "__MACOSX/" folder paths from archives created by macOS).
-                        base_filename = os.path.basename(file.filename)
+                with zipfile.ZipFile(uploaded_file, 'r') as zfile:
+                    infolist = zfile.infolist()
 
-                        if base_filename.endswith(".archipelago"):
-                            return Markup("Error: Your .zip file contains an .archipelago file. "
-                                          'Did you mean to <a href="/uploads">host a game</a>?')
-                        elif base_filename.endswith(".zip"):
-                            return "Nested .zip files inside a .zip are not supported."
-                        elif banned_file(base_filename):
-                            return ("Uploaded data contained a rom file, which is likely to contain copyrighted "
-                                    "material. Your file was deleted.")
-                        # Ignore dot-files.
-                        elif not base_filename.startswith(".") and allowed_options(base_filename):
+                    if any(file.filename.endswith(".archipelago") for file in infolist):
+                        return Markup("Error: Your .zip file contains an .archipelago file. "
+                                      'Did you mean to <a href="/uploads">host a game</a>?')
+
+                    for file in infolist:
+                        if file.filename.endswith(banned_zip_contents):
+                            return ("Uploaded data contained a rom file, "
+                                    "which is likely to contain copyrighted material. "
+                                    "Your file was deleted.")
+                        elif file.filename.endswith((".yaml", ".json", ".yml", ".txt")):
                             options[file.filename] = zfile.open(file, "r").read()
             else:
                 options[uploaded_file.filename] = uploaded_file.read()
-
     if not options:
-        return f"Did not find any valid files to process. Accepted formats: {allowed_options_extensions}"
+        return "Did not find a .yaml file to process."
     return options
 
 

WebHostLib/customserver.py

@@ -205,12 +205,6 @@ def run_server_process(room_id, ponyconfig: dict, static_server_data: dict,
             ctx.auto_shutdown = Room.get(id=room_id).timeout
         ctx.shutdown_task = asyncio.create_task(auto_shutdown(ctx, []))
         await ctx.shutdown_task
-
-        # ensure auto launch is on the same page in regard to room activity.
-        with db_session:
-            room: Room = Room.get(id=ctx.room_id)
-            room.last_activity = datetime.datetime.utcnow() - datetime.timedelta(seconds=room.timeout + 60)
-
         logging.info("Shutting down")
 
     with Locker(room_id):

WebHostLib/requirements.txt

@@ -5,5 +5,5 @@ Flask-Caching>=2.1.0
 Flask-Compress>=1.14
 Flask-Limiter>=3.5.0
 bokeh>=3.1.1; python_version <= '3.8'
-bokeh>=3.3.2; python_version >= '3.9'
+bokeh>=3.2.2; python_version >= '3.9'
 markupsafe>=2.1.3

WebHostLib/static/assets/player-options.js

@@ -369,7 +369,7 @@ const setPresets = (optionsData, presetName) => {
         break;
       }
 
-      case 'named_range': {
+      case 'special_range': {
         const selectElement = document.querySelector(`select[data-key='${option}']`);
         const rangeElement = document.querySelector(`input[data-key='${option}']`);
         const randomElement = document.querySelector(`.randomize-button[data-key='${option}']`);

WebHostLib/static/assets/weighted-options.js

@@ -576,7 +576,7 @@ class GameSettings {
             option = parseInt(option, 10);
 
             let optionAcceptable = false;
-            if ((option >= setting.min) && (option <= setting.max)) {
+            if ((option > setting.min) && (option < setting.max)) {
               optionAcceptable = true;
             }
             if (setting.hasOwnProperty('value_names') && Object.values(setting.value_names).includes(option)){

WebHostLib/templates/generate.html

@@ -69,8 +69,8 @@
                                     </td>
                                     <td>
                                         <select name="collect_mode" id="collect_mode">
-                                            <option value="auto">Automatic on goal completion</option>
                                             <option value="goal">Allow !collect after goal completion</option>
+                                            <option value="auto">Automatic on goal completion</option>
                                             <option value="auto-enabled">
                                                 Automatic on goal completion and manual !collect
                                             </option>
@@ -93,9 +93,9 @@
                                             {% if race -%}
                                                 <option value="disabled">Disabled in Race mode</option>
                                             {%- else -%}
+                                                <option value="disabled">Disabled</option>
                                                 <option value="goal">Allow !remaining after goal completion</option>
                                                 <option value="enabled">Manual !remaining</option>
-                                                <option value="disabled">Disabled</option>
                                             {%- endif -%}
                                         </select>
                                     </td>
@@ -185,12 +185,12 @@ Warning: playthrough can take a significant amount of time for larger multiworld
                                             </span>
                                         </td>
                                         <td>
-                                            <input type="checkbox" id="plando_items" name="plando_items" value="items">
-                                            <label for="plando_items">Items</label><br>
-
                                             <input type="checkbox" id="plando_bosses" name="plando_bosses" value="bosses" checked>
                                             <label for="plando_bosses">Bosses</label><br>
 
+                                            <input type="checkbox" id="plando_items" name="plando_items" value="items" checked>
+                                            <label for="plando_items">Items</label><br>
+
                                             <input type="checkbox" id="plando_connections" name="plando_connections" value="connections" checked>
                                             <label for="plando_connections">Connections</label><br>
 

WebHostLib/templates/hostRoom.html

@@ -3,16 +3,6 @@
 {% block head %}
     <title>Multiworld {{ room.id|suuid }}</title>
     {% if should_refresh %}<meta http-equiv="refresh" content="2">{% endif %}
-    <meta name="og:site_name" content="Archipelago">
-    <meta property="og:title" content="Multiworld {{ room.id|suuid }}">
-    <meta property="og:type" content="website" />
-    {% if room.seed.slots|length < 2 %}
-    <meta property="og:description" content="{{ room.seed.slots|length }} Player World
-    {% if room.last_port != -1 %}running on {{ config['HOST_ADDRESS'] }} with port {{ room.last_port }}{% endif %}">
-    {% else %}
-    <meta property="og:description" content="{{ room.seed.slots|length }} Players Multiworld
-    {% if room.last_port != -1 %}running on {{ config['HOST_ADDRESS'] }} with port {{ room.last_port }}{% endif %}">
-    {% endif %}
     <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/hostRoom.css") }}"/>
 {% endblock %}
 

WebHostLib/templates/islandFooter.html

@@ -1,6 +1,6 @@
 {% block footer %}
     <footer id="island-footer">
-        <div id="copyright-notice">Copyright 2024 Archipelago</div>
+        <div id="copyright-notice">Copyright 2023 Archipelago</div>
         <div id="links">
             <a href="/sitemap">Site Map</a>
             -

WebHostLib/templates/pageWrapper.html

@@ -16,7 +16,7 @@
 {% with messages = get_flashed_messages() %}
     {% if messages %}
         <div>
-            {% for message in messages | unique %}
+            {% for message in messages %}
                 <div class="user-message">{{ message }}</div>
             {% endfor %}
         </div>

WebHostLib/templates/supportedGames.html

@@ -53,7 +53,7 @@
             {% endif %}
             {% if world.web.options_page is string %}
             <span class="link-spacer">|</span>
-            <a href="{{ world.web.options_page }}">Options Page</a>
+            <a href="{{ world.web.settings_page }}">Options Page</a>
             {% elif world.web.options_page %}
             <span class="link-spacer">|</span>
             <a href="{{ url_for("player_options", game=game_name) }}">Options Page</a>

WebHostLib/tracker.py

@@ -1,5 +1,4 @@
 import datetime
-import collections
 from dataclasses import dataclass
 from typing import Any, Callable, Dict, List, Optional, Set, Tuple
 from uuid import UUID
@@ -9,7 +8,7 @@ from werkzeug.exceptions import abort
 
 from MultiServer import Context, get_saving_second
 from NetUtils import ClientStatus, Hint, NetworkItem, NetworkSlot, SlotType
-from Utils import restricted_loads, KeyedDefaultDict
+from Utils import restricted_loads
 from . import app, cache
 from .models import GameDataPackage, Room
 
@@ -63,18 +62,12 @@ class TrackerData:
         self.location_name_to_id: Dict[str, Dict[str, int]] = {}
 
         # Generate inverse lookup tables from data package, useful for trackers.
-        self.item_id_to_name: Dict[str, Dict[int, str]] = KeyedDefaultDict(lambda game_name: {
-            game_name: KeyedDefaultDict(lambda code: f"Unknown Game {game_name} - Item (ID: {code})")
-        })
-        self.location_id_to_name: Dict[str, Dict[int, str]] = KeyedDefaultDict(lambda game_name: {
-            game_name: KeyedDefaultDict(lambda code: f"Unknown Game {game_name} - Location (ID: {code})")
-        })
+        self.item_id_to_name: Dict[str, Dict[int, str]] = {}
+        self.location_id_to_name: Dict[str, Dict[int, str]] = {}
         for game, game_package in self._multidata["datapackage"].items():
             game_package = restricted_loads(GameDataPackage.get(checksum=game_package["checksum"]).data)
-            self.item_id_to_name[game] = KeyedDefaultDict(lambda code: f"Unknown Item (ID: {code})", {
-                id: name for name, id in game_package["item_name_to_id"].items()})
-            self.location_id_to_name[game] = KeyedDefaultDict(lambda code: f"Unknown Location (ID: {code})", {
-                id: name for name, id in game_package["location_name_to_id"].items()})
+            self.item_id_to_name[game] = {id: name for name, id in game_package["item_name_to_id"].items()}
+            self.location_id_to_name[game] = {id: name for name, id in game_package["location_name_to_id"].items()}
 
             # Normal lookup tables as well.
             self.item_name_to_id[game] = game_package["item_name_to_id"]
@@ -122,10 +115,10 @@ class TrackerData:
         return self._multisave.get("received_items", {}).get((team, player, True), [])
 
     @_cache_results
-    def get_player_inventory_counts(self, team: int, player: int) -> collections.Counter:
+    def get_player_inventory_counts(self, team: int, player: int) -> Dict[int, int]:
         """Retrieves a dictionary of all items received by their id and their received count."""
         items = self.get_player_received_items(team, player)
-        inventory = collections.Counter()
+        inventory = {item: 0 for item in self.item_id_to_name[self.get_player_game(team, player)]}
         for item in items:
             inventory[item.item] += 1
 
@@ -156,15 +149,16 @@ class TrackerData:
         """Retrieves a dictionary of number of completed worlds per team."""
         return {
             team: sum(
-                self.get_player_client_status(team, player) == ClientStatus.CLIENT_GOAL for player in players
-            ) for team, players in self.get_all_players().items()
+                self.get_player_client_status(team, player) == ClientStatus.CLIENT_GOAL
+                for player in players if self.get_slot_info(team, player).type == SlotType.player
+            ) for team, players in self.get_team_players().items()
         }
 
     @_cache_results
     def get_team_hints(self) -> Dict[int, Set[Hint]]:
         """Retrieves a dictionary of all hints per team."""
         hints = {}
-        for team, players in self.get_all_slots().items():
+        for team, players in self.get_team_players().items():
             hints[team] = set()
             for player in players:
                 hints[team] |= self.get_player_hints(team, player)
@@ -176,7 +170,7 @@ class TrackerData:
         """Retrieves a dictionary of total player locations each team has."""
         return {
             team: sum(len(self.get_player_locations(team, player)) for player in players)
-            for team, players in self.get_all_players().items()
+            for team, players in self.get_team_players().items()
         }
 
     @_cache_results
@@ -184,30 +178,16 @@ class TrackerData:
         """Retrieves a dictionary of checked player locations each team has."""
         return {
             team: sum(len(self.get_player_checked_locations(team, player)) for player in players)
-            for team, players in self.get_all_players().items()
+            for team, players in self.get_team_players().items()
         }
 
     # TODO: Change this method to properly build for each team once teams are properly implemented, as they don't
     #       currently exist in multidata to easily look up, so these are all assuming only 1 team: Team #0
     @_cache_results
-    def get_all_slots(self) -> Dict[int, List[int]]:
+    def get_team_players(self) -> Dict[int, List[int]]:
         """Retrieves a dictionary of all players ids on each team."""
         return {
-            0: [
-                player for player, slot_info in self._multidata["slot_info"].items()
-            ]
-        }
-
-    # TODO: Change this method to properly build for each team once teams are properly implemented, as they don't
-    #       currently exist in multidata to easily look up, so these are all assuming only 1 team: Team #0
-    @_cache_results
-    def get_all_players(self) -> Dict[int, List[int]]:
-        """Retrieves a dictionary of all player slot-type players ids on each team."""
-        return {
-            0: [
-                player for player, slot_info in self._multidata["slot_info"].items()
-                if self.get_slot_info(0, player).type == SlotType.player
-            ]
+            0: [player for player, slot_info in self._multidata["slot_info"].items()]
         }
 
     @_cache_results
@@ -223,7 +203,7 @@ class TrackerData:
         """Retrieves a dictionary of all locations and their associated item metadata per player."""
         return {
             (team, player): self.get_player_locations(team, player)
-            for team, players in self.get_all_players().items() for player in players
+            for team, players in self.get_team_players().items() for player in players
         }
 
     @_cache_results
@@ -231,7 +211,7 @@ class TrackerData:
         """Retrieves a dictionary of games for each player."""
         return {
             (team, player): self.get_player_game(team, player)
-            for team, players in self.get_all_slots().items() for player in players
+            for team, players in self.get_team_players().items() for player in players
         }
 
     @_cache_results
@@ -239,7 +219,7 @@ class TrackerData:
         """Retrieves a dictionary of all locations complete per player."""
         return {
             (team, player): len(self.get_player_checked_locations(team, player))
-            for team, players in self.get_all_players().items() for player in players
+            for team, players in self.get_team_players().items() for player in players
         }
 
     @_cache_results
@@ -247,14 +227,14 @@ class TrackerData:
         """Retrieves a dictionary of all ClientStatus values per player."""
         return {
             (team, player): self.get_player_client_status(team, player)
-            for team, players in self.get_all_players().items() for player in players
+            for team, players in self.get_team_players().items() for player in players
         }
 
     @_cache_results
     def get_room_long_player_names(self) -> Dict[TeamPlayer, str]:
         """Retrieves a dictionary of names with aliases for each player."""
         long_player_names = {}
-        for team, players in self.get_all_slots().items():
+        for team, players in self.get_team_players().items():
             for player in players:
                 alias = self.get_player_alias(team, player)
                 if alias:
@@ -390,8 +370,7 @@ def render_generic_multiworld_tracker(tracker_data: TrackerData, enabled_tracker
         enabled_trackers=enabled_trackers,
         current_tracker="Generic",
         room=tracker_data.room,
-        all_slots=tracker_data.get_all_slots(),
-        room_players=tracker_data.get_all_players(),
+        room_players=tracker_data.get_team_players(),
         locations=tracker_data.get_room_locations(),
         locations_complete=tracker_data.get_room_locations_complete(),
         total_team_locations=tracker_data.get_team_locations_total_count(),
@@ -410,6 +389,7 @@ def render_generic_multiworld_tracker(tracker_data: TrackerData, enabled_tracker
 
 # TODO: This is a temporary solution until a proper Tracker API can be implemented for tracker templates and data to
 #       live in their respective world folders.
+import collections
 
 from worlds import network_data_package
 
@@ -420,7 +400,7 @@ if "Factorio" in network_data_package["games"]:
             (team, player): {
                 tracker_data.item_id_to_name["Factorio"][item_id]: count
                 for item_id, count in tracker_data.get_player_inventory_counts(team, player).items()
-            } for team, players in tracker_data.get_all_slots().items() for player in players
+            } for team, players in tracker_data.get_team_players().items() for player in players
             if tracker_data.get_player_game(team, player) == "Factorio"
         }
 
@@ -429,8 +409,7 @@ if "Factorio" in network_data_package["games"]:
             enabled_trackers=enabled_trackers,
             current_tracker="Factorio",
             room=tracker_data.room,
-            all_slots=tracker_data.get_all_slots(),
-            room_players=tracker_data.get_all_players(),
+            room_players=tracker_data.get_team_players(),
             locations=tracker_data.get_room_locations(),
             locations_complete=tracker_data.get_room_locations_complete(),
             total_team_locations=tracker_data.get_team_locations_total_count(),
@@ -568,7 +547,7 @@ if "A Link to the Past" in network_data_package["games"]:
                 if area_name != "Total" else tracker_data._multidata["checks_in_area"][player]["Total"]
                 for area_name in ordered_areas
             }
-            for team, players in tracker_data.get_all_slots().items()
+            for team, players in tracker_data.get_team_players().items()
             for player in players
             if tracker_data.get_slot_info(team, player).type != SlotType.group and
             tracker_data.get_slot_info(team, player).game == "A Link to the Past"
@@ -606,7 +585,7 @@ if "A Link to the Past" in network_data_package["games"]:
 
         player_location_to_area = {
             (team, player): _get_location_table(tracker_data._multidata["checks_in_area"][player])
-            for team, players in tracker_data.get_all_slots().items()
+            for team, players in tracker_data.get_team_players().items()
             for player in players
             if tracker_data.get_slot_info(team, player).type != SlotType.group and
             tracker_data.get_slot_info(team, player).game == "A Link to the Past"
@@ -614,15 +593,15 @@ if "A Link to the Past" in network_data_package["games"]:
 
         checks_done: Dict[TeamPlayer, Dict[str: int]] = {
             (team, player): {location_name: 0 for location_name in default_locations}
-            for team, players in tracker_data.get_all_slots().items()
+            for team, players in tracker_data.get_team_players().items()
             for player in players
             if tracker_data.get_slot_info(team, player).type != SlotType.group and
             tracker_data.get_slot_info(team, player).game == "A Link to the Past"
         }
 
         inventories: Dict[TeamPlayer, Dict[int, int]] = {}
-        player_big_key_locations = {(player): set() for player in tracker_data.get_all_slots()[0]}
-        player_small_key_locations = {player: set() for player in tracker_data.get_all_slots()[0]}
+        player_big_key_locations = {(player): set() for player in tracker_data.get_team_players()[0]}
+        player_small_key_locations = {player: set() for player in tracker_data.get_team_players()[0]}
         group_big_key_locations = set()
         group_key_locations = set()
 
@@ -660,8 +639,7 @@ if "A Link to the Past" in network_data_package["games"]:
             enabled_trackers=enabled_trackers,
             current_tracker="A Link to the Past",
             room=tracker_data.room,
-            all_slots=tracker_data.get_all_slots(),
-            room_players=tracker_data.get_all_players(),
+            room_players=tracker_data.get_team_players(),
             locations=tracker_data.get_room_locations(),
             locations_complete=tracker_data.get_room_locations_complete(),
             total_team_locations=tracker_data.get_team_locations_total_count(),

WebHostLib/upload.py

@@ -11,46 +11,17 @@ from flask import request, flash, redirect, url_for, session, render_template
 from markupsafe import Markup
 from pony.orm import commit, flush, select, rollback
 from pony.orm.core import TransactionIntegrityError
-import schema
 
 import MultiServer
 from NetUtils import SlotType
 from Utils import VersionException, __version__
-from worlds import GamesPackage
 from worlds.Files import AutoPatchRegister
-from worlds.AutoWorld import data_package_checksum
 from . import app
 from .models import Seed, Room, Slot, GameDataPackage
 
-banned_extensions = (".sfc", ".z64", ".n64", ".nes", ".smc", ".sms", ".gb", ".gbc", ".gba")
-allowed_options_extensions = (".yaml", ".json", ".yml", ".txt", ".zip")
-allowed_generation_extensions = (".archipelago", ".zip")
-
-games_package_schema = schema.Schema({
-    "item_name_groups": {str: [str]},
-    "item_name_to_id": {str: int},
-    "location_name_groups": {str: [str]},
-    "location_name_to_id": {str: int},
-    schema.Optional("checksum"): str,
-    schema.Optional("version"): int,
-})
-
-
-def allowed_options(filename: str) -> bool:
-    return filename.endswith(allowed_options_extensions)
-
-
-def allowed_generation(filename: str) -> bool:
-    return filename.endswith(allowed_generation_extensions)
-
-
-def banned_file(filename: str) -> bool:
-    return filename.endswith(banned_extensions)
-
+banned_zip_contents = (".sfc", ".z64", ".n64", ".sms", ".gb")
 
 def process_multidata(compressed_multidata, files={}):
-    game_data: GamesPackage
-
     decompressed_multidata = MultiServer.Context.decompress(compressed_multidata)
 
     slots: typing.Set[Slot] = set()
@@ -59,19 +30,11 @@ def process_multidata(compressed_multidata, files={}):
         game_data_packages: typing.List[GameDataPackage] = []
         for game, game_data in decompressed_multidata["datapackage"].items():
             if game_data.get("checksum"):
-                original_checksum = game_data.pop("checksum")
-                game_data = games_package_schema.validate(game_data)
-                game_data = {key: value for key, value in sorted(game_data.items())}
-                game_data["checksum"] = data_package_checksum(game_data)
                 game_data_package = GameDataPackage(checksum=game_data["checksum"],
                                                     data=pickle.dumps(game_data))
-                if original_checksum != game_data["checksum"]:
-                    raise Exception(f"Original checksum {original_checksum} != "
-                                    f"calculated checksum {game_data['checksum']} "
-                                    f"for game {game}.")
                 decompressed_multidata["datapackage"][game] = {
                     "version": game_data.get("version", 0),
-                    "checksum": game_data["checksum"],
+                    "checksum": game_data["checksum"]
                 }
                 try:
                     commit()  # commit game data package
@@ -86,21 +49,20 @@ def process_multidata(compressed_multidata, files={}):
             if slot_info.type == SlotType.group:
                 continue
             slots.add(Slot(data=files.get(slot, None),
-                           player_name=slot_info.name,
-                           player_id=slot,
-                           game=slot_info.game))
+                            player_name=slot_info.name,
+                            player_id=slot,
+                            game=slot_info.game))
         flush()  # commit slots
 
     compressed_multidata = compressed_multidata[0:1] + zlib.compress(pickle.dumps(decompressed_multidata), 9)
     return slots, compressed_multidata
 
-
 def upload_zip_to_db(zfile: zipfile.ZipFile, owner=None, meta={"race": False}, sid=None):
     if not owner:
         owner = session["_id"]
     infolist = zfile.infolist()
-    if all(allowed_options(file.filename) or file.is_dir() for file in infolist):
-        flash(Markup("Error: Your .zip file only contains options files. "
+    if all(file.filename.endswith((".yaml", ".yml")) or file.is_dir() for file in infolist):
+        flash(Markup("Error: Your .zip file only contains .yaml files. "
                      'Did you mean to <a href="/generate">generate a game</a>?'))
         return
 
@@ -111,7 +73,7 @@ def upload_zip_to_db(zfile: zipfile.ZipFile, owner=None, meta={"race": False}, s
     # Load files.
     for file in infolist:
         handler = AutoPatchRegister.get_handler(file.filename)
-        if banned_file(file.filename):
+        if file.filename.endswith(banned_zip_contents):
             return "Uploaded data contained a rom file, which is likely to contain copyrighted material. " \
                    "Your file was deleted."
 
@@ -174,34 +136,35 @@ def upload_zip_to_db(zfile: zipfile.ZipFile, owner=None, meta={"race": False}, s
         flash("No multidata was found in the zip file, which is required.")
 
 
-@app.route("/uploads", methods=["GET", "POST"])
+@app.route('/uploads', methods=['GET', 'POST'])
 def uploads():
-    if request.method == "POST":
-        # check if the POST request has a file part.
-        if "file" not in request.files:
-            flash("No file part in POST request.")
+    if request.method == 'POST':
+        # check if the post request has the file part
+        if 'file' not in request.files:
+            flash('No file part')
         else:
-            uploaded_file = request.files["file"]
-            # If the user does not select file, the browser will still submit an empty string without a file name.
-            if uploaded_file.filename == "":
-                flash("No selected file.")
-            elif uploaded_file and allowed_generation(uploaded_file.filename):
-                if zipfile.is_zipfile(uploaded_file):
-                    with zipfile.ZipFile(uploaded_file, "r") as zfile:
+            file = request.files['file']
+            # if user does not select file, browser also
+            # submit an empty part without filename
+            if file.filename == '':
+                flash('No selected file')
+            elif file and allowed_file(file.filename):
+                if zipfile.is_zipfile(file):
+                    with zipfile.ZipFile(file, 'r') as zfile:
                         try:
                             res = upload_zip_to_db(zfile)
                         except VersionException:
                             flash(f"Could not load multidata. Wrong Version detected.")
                         else:
-                            if res is str:
+                            if type(res) == str:
                                 return res
                             elif res:
                                 return redirect(url_for("view_seed", seed=res.id))
                 else:
-                    uploaded_file.seek(0)  # offset from is_zipfile check
+                    file.seek(0)  # offset from is_zipfile check
                     # noinspection PyBroadException
                     try:
-                        multidata = uploaded_file.read()
+                        multidata = file.read()
                         slots, multidata = process_multidata(multidata)
                     except Exception as e:
                         flash(f"Could not load multidata. File may be corrupted or incompatible. ({e})")
@@ -219,3 +182,7 @@ def user_content():
     rooms = select(room for room in Room if room.owner == session["_id"])
     seeds = select(seed for seed in Seed if seed.owner == session["_id"])
     return render_template("userContent.html", rooms=rooms, seeds=seeds)
+
+
+def allowed_file(filename):
+    return filename.endswith(('.archipelago', ".zip"))

Zelda1Client.py

@@ -13,6 +13,7 @@ from typing import List
 
 import Utils
 from Utils import async_start
+from worlds import lookup_any_location_id_to_name
 from CommonClient import CommonContext, server_loop, gui_enabled, console_loop, ClientCommandProcessor, logger, \
     get_base_parser
 
@@ -152,7 +153,7 @@ def get_payload(ctx: ZeldaContext):
 
 
 def reconcile_shops(ctx: ZeldaContext):
-    checked_location_names = [ctx.location_names[location] for location in ctx.checked_locations]
+    checked_location_names = [lookup_any_location_id_to_name[location] for location in ctx.checked_locations]
     shops = [location for location in checked_location_names if "Shop" in location]
     left_slots = [shop for shop in shops if "Left" in shop]
     middle_slots = [shop for shop in shops if "Middle" in shop]
@@ -190,7 +191,7 @@ async def parse_locations(locations_array, ctx: ZeldaContext, force: bool, zone=
         locations_checked = []
         location = None
         for location in ctx.missing_locations:
-            location_name = ctx.location_names[location]
+            location_name = lookup_any_location_id_to_name[location]
 
             if location_name in Locations.overworld_locations and zone == "overworld":
                 status = locations_array[Locations.major_location_offsets[location_name]]

ZillionClient.py

@@ -1,10 +1,505 @@
-import ModuleUpdate
-ModuleUpdate.update()
+import asyncio
+import base64
+import platform
+from typing import Any, ClassVar, Coroutine, Dict, List, Optional, Protocol, Tuple, Type, cast
 
-import Utils  # noqa: E402
+# CommonClient import first to trigger ModuleUpdater
+from CommonClient import CommonContext, server_loop, gui_enabled, \
+    ClientCommandProcessor, logger, get_base_parser
+from NetUtils import ClientStatus
+import Utils
+from Utils import async_start
+
+import colorama  # type: ignore
+
+from zilliandomizer.zri.memory import Memory
+from zilliandomizer.zri import events
+from zilliandomizer.utils.loc_name_maps import id_to_loc
+from zilliandomizer.options import Chars
+from zilliandomizer.patch import RescueInfo
+
+from worlds.zillion.id_maps import make_id_to_others
+from worlds.zillion.config import base_id, zillion_map
+
+
+class ZillionCommandProcessor(ClientCommandProcessor):
+    ctx: "ZillionContext"
+
+    def _cmd_sms(self) -> None:
+        """ Tell the client that Zillion is running in RetroArch. """
+        logger.info("ready to look for game")
+        self.ctx.look_for_retroarch.set()
+
+    def _cmd_map(self) -> None:
+        """ Toggle view of the map tracker. """
+        self.ctx.ui_toggle_map()
+
+
+class ToggleCallback(Protocol):
+    def __call__(self) -> None: ...
+
+
+class SetRoomCallback(Protocol):
+    def __call__(self, rooms: List[List[int]]) -> None: ...
+
+
+class ZillionContext(CommonContext):
+    game = "Zillion"
+    command_processor: Type[ClientCommandProcessor] = ZillionCommandProcessor
+    items_handling = 1  # receive items from other players
+
+    known_name: Optional[str]
+    """ This is almost the same as `auth` except `auth` is reset to `None` when server disconnects, and this isn't. """
+
+    from_game: "asyncio.Queue[events.EventFromGame]"
+    to_game: "asyncio.Queue[events.EventToGame]"
+    ap_local_count: int
+    """ local checks watched by server """
+    next_item: int
+    """ index in `items_received` """
+    ap_id_to_name: Dict[int, str]
+    ap_id_to_zz_id: Dict[int, int]
+    start_char: Chars = "JJ"
+    rescues: Dict[int, RescueInfo] = {}
+    loc_mem_to_id: Dict[int, int] = {}
+    got_room_info: asyncio.Event
+    """ flag for connected to server """
+    got_slot_data: asyncio.Event
+    """ serves as a flag for whether I am logged in to the server """
+
+    look_for_retroarch: asyncio.Event
+    """
+    There is a bug in Python in Windows
+    https://github.com/python/cpython/issues/91227
+    that makes it so if I look for RetroArch before it's ready,
+    it breaks the asyncio udp transport system.
+
+    As a workaround, we don't look for RetroArch until this event is set.
+    """
+
+    ui_toggle_map: ToggleCallback
+    ui_set_rooms: SetRoomCallback
+    """ parameter is y 16 x 8 numbers to show in each room """
+
+    def __init__(self,
+                 server_address: str,
+                 password: str) -> None:
+        super().__init__(server_address, password)
+        self.known_name = None
+        self.from_game = asyncio.Queue()
+        self.to_game = asyncio.Queue()
+        self.got_room_info = asyncio.Event()
+        self.got_slot_data = asyncio.Event()
+        self.ui_toggle_map = lambda: None
+        self.ui_set_rooms = lambda rooms: None
+
+        self.look_for_retroarch = asyncio.Event()
+        if platform.system() != "Windows":
+            # asyncio udp bug is only on Windows
+            self.look_for_retroarch.set()
+
+        self.reset_game_state()
+
+    def reset_game_state(self) -> None:
+        for _ in range(self.from_game.qsize()):
+            self.from_game.get_nowait()
+        for _ in range(self.to_game.qsize()):
+            self.to_game.get_nowait()
+        self.got_slot_data.clear()
+
+        self.ap_local_count = 0
+        self.next_item = 0
+        self.ap_id_to_name = {}
+        self.ap_id_to_zz_id = {}
+        self.rescues = {}
+        self.loc_mem_to_id = {}
+
+        self.locations_checked.clear()
+        self.missing_locations.clear()
+        self.checked_locations.clear()
+        self.finished_game = False
+        self.items_received.clear()
+
+    # override
+    def on_deathlink(self, data: Dict[str, Any]) -> None:
+        self.to_game.put_nowait(events.DeathEventToGame())
+        return super().on_deathlink(data)
+
+    # override
+    async def server_auth(self, password_requested: bool = False) -> None:
+        if password_requested and not self.password:
+            await super().server_auth(password_requested)
+        if not self.auth:
+            logger.info('waiting for connection to game...')
+            return
+        logger.info("logging in to server...")
+        await self.send_connect()
+
+    # override
+    def run_gui(self) -> None:
+        from kvui import GameManager
+        from kivy.core.text import Label as CoreLabel
+        from kivy.graphics import Ellipse, Color, Rectangle
+        from kivy.uix.layout import Layout
+        from kivy.uix.widget import Widget
+
+        class ZillionManager(GameManager):
+            logging_pairs = [
+                ("Client", "Archipelago")
+            ]
+            base_title = "Archipelago Zillion Client"
+
+            class MapPanel(Widget):
+                MAP_WIDTH: ClassVar[int] = 281
+
+                _number_textures: List[Any] = []
+                rooms: List[List[int]] = []
+
+                def __init__(self, **kwargs: Any) -> None:
+                    super().__init__(**kwargs)
+
+                    self.rooms = [[0 for _ in range(8)] for _ in range(16)]
+
+                    self._make_numbers()
+                    self.update_map()
+
+                    self.bind(pos=self.update_map)
+                    # self.bind(size=self.update_bg)
+
+                def _make_numbers(self) -> None:
+                    self._number_textures = []
+                    for n in range(10):
+                        label = CoreLabel(text=str(n), font_size=22, color=(0.1, 0.9, 0, 1))
+                        label.refresh()
+                        self._number_textures.append(label.texture)
+
+                def update_map(self, *args: Any) -> None:
+                    self.canvas.clear()
+
+                    with self.canvas:
+                        Color(1, 1, 1, 1)
+                        Rectangle(source=zillion_map,
+                                  pos=self.pos,
+                                  size=(ZillionManager.MapPanel.MAP_WIDTH,
+                                        int(ZillionManager.MapPanel.MAP_WIDTH * 1.456)))  # aspect ratio of that image
+                        for y in range(16):
+                            for x in range(8):
+                                num = self.rooms[15 - y][x]
+                                if num > 0:
+                                    Color(0, 0, 0, 0.4)
+                                    pos = [self.pos[0] + 17 + x * 32, self.pos[1] + 14 + y * 24]
+                                    Ellipse(size=[22, 22], pos=pos)
+                                    Color(1, 1, 1, 1)
+                                    pos = [self.pos[0] + 22 + x * 32, self.pos[1] + 12 + y * 24]
+                                    num_texture = self._number_textures[num]
+                                    Rectangle(texture=num_texture, size=num_texture.size, pos=pos)
+
+            def build(self) -> Layout:
+                container = super().build()
+                self.map_widget = ZillionManager.MapPanel(size_hint_x=None, width=0)
+                self.main_area_container.add_widget(self.map_widget)
+                return container
+
+            def toggle_map_width(self) -> None:
+                if self.map_widget.width == 0:
+                    self.map_widget.width = ZillionManager.MapPanel.MAP_WIDTH
+                else:
+                    self.map_widget.width = 0
+                self.container.do_layout()
+
+            def set_rooms(self, rooms: List[List[int]]) -> None:
+                self.map_widget.rooms = rooms
+                self.map_widget.update_map()
+
+        self.ui = ZillionManager(self)
+        self.ui_toggle_map = lambda: self.ui.toggle_map_width()
+        self.ui_set_rooms = lambda rooms: self.ui.set_rooms(rooms)
+        run_co: Coroutine[Any, Any, None] = self.ui.async_run()
+        self.ui_task = asyncio.create_task(run_co, name="UI")
+
+    def on_package(self, cmd: str, args: Dict[str, Any]) -> None:
+        self.room_item_numbers_to_ui()
+        if cmd == "Connected":
+            logger.info("logged in to Archipelago server")
+            if "slot_data" not in args:
+                logger.warn("`Connected` packet missing `slot_data`")
+                return
+            slot_data = args["slot_data"]
+
+            if "start_char" not in slot_data:
+                logger.warn("invalid Zillion `Connected` packet, `slot_data` missing `start_char`")
+                return
+            self.start_char = slot_data['start_char']
+            if self.start_char not in {"Apple", "Champ", "JJ"}:
+                logger.warn("invalid Zillion `Connected` packet, "
+                            f"`slot_data` `start_char` has invalid value: {self.start_char}")
+
+            if "rescues" not in slot_data:
+                logger.warn("invalid Zillion `Connected` packet, `slot_data` missing `rescues`")
+                return
+            rescues = slot_data["rescues"]
+            self.rescues = {}
+            for rescue_id, json_info in rescues.items():
+                assert rescue_id in ("0", "1"), f"invalid rescue_id in Zillion slot_data: {rescue_id}"
+                # TODO: just take start_char out of the RescueInfo so there's no opportunity for a mismatch?
+                assert json_info["start_char"] == self.start_char, \
+                    f'mismatch in Zillion slot data: {json_info["start_char"]} {self.start_char}'
+                ri = RescueInfo(json_info["start_char"],
+                                json_info["room_code"],
+                                json_info["mask"])
+                self.rescues[0 if rescue_id == "0" else 1] = ri
+
+            if "loc_mem_to_id" not in slot_data:
+                logger.warn("invalid Zillion `Connected` packet, `slot_data` missing `loc_mem_to_id`")
+                return
+            loc_mem_to_id = slot_data["loc_mem_to_id"]
+            self.loc_mem_to_id = {}
+            for mem_str, id_str in loc_mem_to_id.items():
+                mem = int(mem_str)
+                id_ = int(id_str)
+                room_i = mem // 256
+                assert 0 <= room_i < 74
+                assert id_ in id_to_loc
+                self.loc_mem_to_id[mem] = id_
+
+            if len(self.loc_mem_to_id) != 394:
+                logger.warn("invalid Zillion `Connected` packet, "
+                            f"`slot_data` missing locations in `loc_mem_to_id` - len {len(self.loc_mem_to_id)}")
+
+            self.got_slot_data.set()
+
+            payload = {
+                "cmd": "Get",
+                "keys": [f"zillion-{self.auth}-doors"]
+            }
+            async_start(self.send_msgs([payload]))
+        elif cmd == "Retrieved":
+            if "keys" not in args:
+                logger.warning(f"invalid Retrieved packet to ZillionClient: {args}")
+                return
+            keys = cast(Dict[str, Optional[str]], args["keys"])
+            doors_b64 = keys[f"zillion-{self.auth}-doors"]
+            if doors_b64:
+                logger.info("received door data from server")
+                doors = base64.b64decode(doors_b64)
+                self.to_game.put_nowait(events.DoorEventToGame(doors))
+        elif cmd == "RoomInfo":
+            self.seed_name = args["seed_name"]
+            self.got_room_info.set()
+
+    def room_item_numbers_to_ui(self) -> None:
+        rooms = [[0 for _ in range(8)] for _ in range(16)]
+        for loc_id in self.missing_locations:
+            loc_id_small = loc_id - base_id
+            loc_name = id_to_loc[loc_id_small]
+            y = ord(loc_name[0]) - 65
+            x = ord(loc_name[2]) - 49
+            if y == 9 and x == 5:
+                # don't show main computer in numbers
+                continue
+            assert (0 <= y < 16) and (0 <= x < 8), f"invalid index from location name {loc_name}"
+            rooms[y][x] += 1
+        # TODO: also add locations with locals lost from loading save state or reset
+        self.ui_set_rooms(rooms)
+
+    def process_from_game_queue(self) -> None:
+        if self.from_game.qsize():
+            event_from_game = self.from_game.get_nowait()
+            if isinstance(event_from_game, events.AcquireLocationEventFromGame):
+                server_id = event_from_game.id + base_id
+                loc_name = id_to_loc[event_from_game.id]
+                self.locations_checked.add(server_id)
+                if server_id in self.missing_locations:
+                    self.ap_local_count += 1
+                    n_locations = len(self.missing_locations) + len(self.checked_locations) - 1  # -1 to ignore win
+                    logger.info(f'New Check: {loc_name} ({self.ap_local_count}/{n_locations})')
+                    async_start(self.send_msgs([
+                        {"cmd": 'LocationChecks', "locations": [server_id]}
+                    ]))
+                else:
+                    # This will happen a lot in Zillion,
+                    # because all the key words are local and unwatched by the server.
+                    logger.debug(f"DEBUG: {loc_name} not in missing")
+            elif isinstance(event_from_game, events.DeathEventFromGame):
+                async_start(self.send_death())
+            elif isinstance(event_from_game, events.WinEventFromGame):
+                if not self.finished_game:
+                    async_start(self.send_msgs([
+                        {"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}
+                    ]))
+                    self.finished_game = True
+            elif isinstance(event_from_game, events.DoorEventFromGame):
+                if self.auth:
+                    doors_b64 = base64.b64encode(event_from_game.doors).decode()
+                    payload = {
+                        "cmd": "Set",
+                        "key": f"zillion-{self.auth}-doors",
+                        "operations": [{"operation": "replace", "value": doors_b64}]
+                    }
+                    async_start(self.send_msgs([payload]))
+            else:
+                logger.warning(f"WARNING: unhandled event from game {event_from_game}")
+
+    def process_items_received(self) -> None:
+        if len(self.items_received) > self.next_item:
+            zz_item_ids = [self.ap_id_to_zz_id[item.item] for item in self.items_received]
+            for index in range(self.next_item, len(self.items_received)):
+                ap_id = self.items_received[index].item
+                from_name = self.player_names[self.items_received[index].player]
+                # TODO: colors in this text, like sni client?
+                logger.info(f'received {self.ap_id_to_name[ap_id]} from {from_name}')
+            self.to_game.put_nowait(
+                events.ItemEventToGame(zz_item_ids)
+            )
+            self.next_item = len(self.items_received)
+
+
+def name_seed_from_ram(data: bytes) -> Tuple[str, str]:
+    """ returns player name, and end of seed string """
+    if len(data) == 0:
+        # no connection to game
+        return "", "xxx"
+    null_index = data.find(b'\x00')
+    if null_index == -1:
+        logger.warning(f"invalid game id in rom {repr(data)}")
+        null_index = len(data)
+    name = data[:null_index].decode()
+    null_index_2 = data.find(b'\x00', null_index + 1)
+    if null_index_2 == -1:
+        null_index_2 = len(data)
+    seed_name = data[null_index + 1:null_index_2].decode()
+
+    return name, seed_name
+
+
+async def zillion_sync_task(ctx: ZillionContext) -> None:
+    logger.info("started zillion sync task")
+
+    # to work around the Python bug where we can't check for RetroArch
+    if not ctx.look_for_retroarch.is_set():
+        logger.info("Start Zillion in RetroArch, then use the /sms command to connect to it.")
+    await asyncio.wait((
+        asyncio.create_task(ctx.look_for_retroarch.wait()),
+        asyncio.create_task(ctx.exit_event.wait())
+    ), return_when=asyncio.FIRST_COMPLETED)
+
+    last_log = ""
+
+    def log_no_spam(msg: str) -> None:
+        nonlocal last_log
+        if msg != last_log:
+            last_log = msg
+            logger.info(msg)
+
+    # to only show this message once per client run
+    help_message_shown = False
+
+    with Memory(ctx.from_game, ctx.to_game) as memory:
+        while not ctx.exit_event.is_set():
+            ram = await memory.read()
+            game_id = memory.get_rom_to_ram_data(ram)
+            name, seed_end = name_seed_from_ram(game_id)
+            if len(name):
+                if name == ctx.known_name:
+                    ctx.auth = name
+                    # this is the name we know
+                    if ctx.server and ctx.server.socket:  # type: ignore
+                        if ctx.got_room_info.is_set():
+                            if ctx.seed_name and ctx.seed_name.endswith(seed_end):
+                                # correct seed
+                                if memory.have_generation_info():
+                                    log_no_spam("everything connected")
+                                    await memory.process_ram(ram)
+                                    ctx.process_from_game_queue()
+                                    ctx.process_items_received()
+                                else:  # no generation info
+                                    if ctx.got_slot_data.is_set():
+                                        memory.set_generation_info(ctx.rescues, ctx.loc_mem_to_id)
+                                        ctx.ap_id_to_name, ctx.ap_id_to_zz_id, _ap_id_to_zz_item = \
+                                            make_id_to_others(ctx.start_char)
+                                        ctx.next_item = 0
+                                        ctx.ap_local_count = len(ctx.checked_locations)
+                                    else:  # no slot data yet
+                                        async_start(ctx.send_connect())
+                                        log_no_spam("logging in to server...")
+                                        await asyncio.wait((
+                                            asyncio.create_task(ctx.got_slot_data.wait()),
+                                            asyncio.create_task(ctx.exit_event.wait()),
+                                            asyncio.create_task(asyncio.sleep(6))
+                                        ), return_when=asyncio.FIRST_COMPLETED)  # to not spam connect packets
+                            else:  # not correct seed name
+                                log_no_spam("incorrect seed - did you mix up roms?")
+                        else:  # no room info
+                            # If we get here, it looks like `RoomInfo` packet got lost
+                            log_no_spam("waiting for room info from server...")
+                    else:  # server not connected
+                        log_no_spam("waiting for server connection...")
+                else:  # new game
+                    log_no_spam("connected to new game")
+                    await ctx.disconnect()
+                    ctx.reset_server_state()
+                    ctx.seed_name = None
+                    ctx.got_room_info.clear()
+                    ctx.reset_game_state()
+                    memory.reset_game_state()
+
+                    ctx.auth = name
+                    ctx.known_name = name
+                    async_start(ctx.connect())
+                    await asyncio.wait((
+                        asyncio.create_task(ctx.got_room_info.wait()),
+                        asyncio.create_task(ctx.exit_event.wait()),
+                        asyncio.create_task(asyncio.sleep(6))
+                    ), return_when=asyncio.FIRST_COMPLETED)
+            else:  # no name found in game
+                if not help_message_shown:
+                    logger.info('In RetroArch, make sure "Settings > Network > Network Commands" is on.')
+                    help_message_shown = True
+                log_no_spam("looking for connection to game...")
+                await asyncio.sleep(0.3)
+
+            await asyncio.sleep(0.09375)
+        logger.info("zillion sync task ending")
+
+
+async def main() -> None:
+    parser = get_base_parser()
+    parser.add_argument('diff_file', default="", type=str, nargs="?",
+                        help='Path to a .apzl Archipelago Binary Patch file')
+    # SNI parser.add_argument('--loglevel', default='info', choices=['debug', 'info', 'warning', 'error', 'critical'])
+    args = parser.parse_args()
+    print(args)
+
+    if args.diff_file:
+        import Patch
+        logger.info("patch file was supplied - creating sms rom...")
+        meta, rom_file = Patch.create_rom_file(args.diff_file)
+        if "server" in meta:
+            args.connect = meta["server"]
+        logger.info(f"wrote rom file to {rom_file}")
+
+    ctx = ZillionContext(args.connect, args.password)
+    if ctx.server_task is None:
+        ctx.server_task = asyncio.create_task(server_loop(ctx), name="ServerLoop")
+
+    if gui_enabled:
+        ctx.run_gui()
+    ctx.run_cli()
+
+    sync_task = asyncio.create_task(zillion_sync_task(ctx))
+
+    await ctx.exit_event.wait()
+
+    ctx.server_address = None
+    logger.debug("waiting for sync task to end")
+    await sync_task
+    logger.debug("sync task ended")
+    await ctx.shutdown()
 
-from worlds.zillion.client import launch  # noqa: E402
 
 if __name__ == "__main__":
     Utils.init_logging("ZillionClient", exception_logger="Client")
-    launch()
+
+    colorama.init()
+    asyncio.run(main())
+    colorama.deinit()

data/lua/connector_bizhawk_generic.lua

@@ -456,7 +456,6 @@ function send_receive ()
                         failed_guard_response = response
                     end
                 else
-                    if type(response) ~= "string" then response = "Unknown error" end
                     res[i] = {type = "ERROR", err = response}
                 end
             end
@@ -586,7 +585,7 @@ else
     -- misaligned, so for GB and GBC we explicitly set the callback on
     -- vblank instead.
     -- https://github.com/TASEmulators/BizHawk/issues/3711
-    if emu.getsystemid() == "GB" or emu.getsystemid() == "GBC" or emu.getsystemid() == "SGB" then
+    if emu.getsystemid() == "GB" or emu.getsystemid() == "GBC" then
         event.onmemoryexecute(tick, 0x40, "tick", "System Bus")
     else
         event.onframeend(tick)

docs/CODEOWNERS

@@ -164,9 +164,6 @@
 # The Legend of Zelda (1)
 /worlds/tloz/ @Rosalie-A @t3hf1gm3nt
 
-# TUNIC
-/worlds/tunic/ @silent-destroyer
-
 # Undertale
 /worlds/undertale/ @jonloveslegos
 

docs/contributing.md

@@ -7,7 +7,7 @@ Contributions are welcome. We have a few requests for new contributors:
 
 * **Ensure that critical changes are covered by tests.** 
 It is strongly recommended that unit tests are used to avoid regression and to ensure everything is still working.
-If you wish to contribute by adding a new game, please take a look at the [logic unit test documentation](/docs/tests.md).
+If you wish to contribute by adding a new game, please take a look at the [logic unit test documentation](/docs/world%20api.md#tests).
 If you wish to contribute to the website, please take a look at [these tests](/test/webhost).
 
 * **Do not introduce unit test failures/regressions.**

docs/network protocol.md

@@ -380,13 +380,12 @@ Additional arguments sent in this package will also be added to the [Retrieved](
 
 Some special keys exist with specific return data, all of them have the prefix `_read_`, so `hints_{team}_{slot}` is `_read_hints_{team}_{slot}`.
 
-| Name                             | Type                          | Notes                                                 |
-|----------------------------------|-------------------------------|-------------------------------------------------------|
-| hints_{team}_{slot}              | list\[[Hint](#Hint)\]         | All Hints belonging to the requested Player.          |
-| slot_data_{slot}                 | dict\[str, any\]              | slot_data belonging to the requested slot.            |
-| item_name_groups_{game_name}     | dict\[str, list\[str\]\]      | item_name_groups belonging to the requested game.     |
-| location_name_groups_{game_name} | dict\[str, list\[str\]\]      | location_name_groups belonging to the requested game. |
-| client_status_{team}_{slot}      | [ClientStatus](#ClientStatus) | The current game status of the requested player.      |
+| Name                         | Type                          | Notes                                             |
+|------------------------------|-------------------------------|---------------------------------------------------|
+| hints_{team}_{slot}          | list\[[Hint](#Hint)\]         | All Hints belonging to the requested Player.      |
+| slot_data_{slot}             | dict\[str, any\]              | slot_data belonging to the requested slot.        |
+| item_name_groups_{game_name} | dict\[str, list\[str\]\]      | item_name_groups belonging to the requested game. |
+| client_status_{team}_{slot}  | [ClientStatus](#ClientStatus) | The current game status of the requested player.  |
 
 ### Set
 Used to write data to the server's data storage, that data can then be shared across worlds or just saved for later. Values for keys in the data storage can be retrieved with a [Get](#Get) package, or monitored with a [SetNotify](#SetNotify) package.
@@ -675,8 +674,8 @@ Tags are represented as a list of strings, the common Client tags follow:
 ### DeathLink
 A special kind of Bounce packet that can be supported by any AP game. It targets the tag "DeathLink" and carries the following data:
 
-| Name   | Type  | Notes                                                                                                                                                  |
-|--------|-------|--------------------------------------------------------------------------------------------------------------------------------------------------------|
-| time   | float | Unix Time Stamp of time of death.                                                                                                                      |
-| cause  | str   | Optional. Text to explain the cause of death. When provided, or checked, this should contain the player name, ex. "Berserker was run over by a train." |
-| source | str   | Name of the player who first died. Can be a slot name, but can also be a name from within a multiplayer game.                                          |
+| Name | Type | Notes |
+| ---- | ---- | ---- |
+| time | float | Unix Time Stamp of time of death. |
+| cause | str | Optional. Text to explain the cause of death, ex. "Berserker was run over by a train." |
+| source | str | Name of the player who first died. Can be a slot name, but can also be a name from within a multiplayer game. |

docs/tests.md

@@ -1,90 +0,0 @@
-# Archipelago Unit Testing API
-
-This document covers some of the generic tests available using Archipelago's unit testing system, as well as some basic
-steps on how to write your own.
-
-## Generic Tests
-
-Some generic tests are run on every World to ensure basic functionality with default options. These basic tests can be
-found in the [general test directory](/test/general).
-
-## Defining World Tests
-
-In order to run tests from your world, you will need to create a `test` package within your world package. This can be
-done by creating a `test` directory with a file named `__init__.py` inside it inside your world. By convention, a base
-for your world tests can be created in this file that you can then import into other modules.
-
-### WorldTestBase
-
-In order to test basic functionality of varying options, as well as to test specific edge cases or that certain
-interactions in the world interact as expected, you will want to use the [WorldTestBase](/test/bases.py). This class
-comes with the basics for test setup as well as a few preloaded tests that most worlds might want to check on varying
-options combinations.
-
-Example `/worlds/<my_game>/test/__init__.py`:
-
-```python
-from test.bases import WorldTestBase
-
-
-class MyGameTestBase(WorldTestBase):
-    game = "My Game"
-```
-
-The basic tests that WorldTestBase comes with include `test_all_state_can_reach_everything`,
-`test_empty_state_can_reach_something`, and `test_fill`. These test that with all collected items everything is
-reachable, with no collected items at least something is reachable, and that a valid multiworld can be completed with
-all steps being called, respectively.
-
-### Writing Tests
-
-#### Using WorldTestBase
-
-Adding runs for the basic tests for a different option combination is as easy as making a new module in the test
-package, creating a class that inherits from your game's TestBase, and defining the options in a dict as a field on the
-class. The new module should be named `test_<something>.py` and have at least one class inheriting from the base, or
-define its own testing methods. Newly defined test methods should follow standard PEP8 snake_case format and also start
-with `test_`.
-
-Example `/worlds/<my_game>/test/test_chest_access.py`:
-
-```python
-from . import MyGameTestBase
-
-
-class TestChestAccess(MyGameTestBase):
-    options = {
-        "difficulty": "easy",
-        "final_boss_hp": 4000,
-    }
-
-    def test_sword_chests(self) -> None:
-        """Test locations that require a sword"""
-        locations = ["Chest1", "Chest2"]
-        items = [["Sword"]]
-        # This tests that the provided locations aren't accessible without the provided items, but can be accessed once
-        # the items are obtained.
-        # This will also check that any locations not provided don't have the same dependency requirement.
-        # Optionally, passing only_check_listed=True to the method will only check the locations provided.
-        self.assertAccessDependency(locations, items)
-```
-
-When tests are run, this class will create a multiworld with a single player having the provided options, and run the
-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).
-
-#### Alternatives to WorldTestBase
-
-Unit tests can also be created using [TestBase](/test/bases.py#L14) 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.
-
-## Running Tests
-
-In PyCharm, running all tests can be done by right-clicking the root `test` directory and selecting `run Python tests`.
-If you do not have pytest installed, you may get import failures. To solve this, edit the run configuration, and set the
-working directory of the run to the Archipelago directory. If you only want to run your world's defined tests, repeat
-the steps for the test directory within your world.

docs/world api.md

@@ -870,7 +870,7 @@ TestBase, and can then define options to test in the class body, and run tests i
 Example `__init__.py`
 
 ```python
-from test.bases import WorldTestBase
+from test.test_base import WorldTestBase
 
 
 class MyGameTestBase(WorldTestBase):
@@ -879,7 +879,7 @@ class MyGameTestBase(WorldTestBase):
 
 Next using the rules defined in the above `set_rules` we can test that the chests have the correct access rules.
 
-Example `test_chest_access.py`
+Example `testChestAccess.py`
 ```python
 from . import MyGameTestBase
 
@@ -899,5 +899,3 @@ class TestChestAccess(MyGameTestBase):
         # this will test that chests 3-5 can't be accessed without any weapon, but can be with just one of them.
         self.assertAccessDependency(locations, items)
 ```
-
-For more information on tests check the [tests doc](tests.md).

inno_setup.iss

@@ -197,7 +197,7 @@ begin
   begin
     // Is the installed version at least the packaged one ?
     Log('VC Redist x64 Version : found ' + strVersion);
-    Result := (CompareStr(strVersion, 'v14.38.33130') < 0);
+    Result := (CompareStr(strVersion, 'v14.32.31332') < 0);
   end
   else
   begin

requirements.txt

@@ -1,13 +1,13 @@
 colorama>=0.4.5
-websockets>=12.0
+websockets>=11.0.3
 PyYAML>=6.0.1
 jellyfish>=1.0.3
 jinja2>=3.1.2
 schema>=0.7.5
-kivy>=2.3.0
+kivy>=2.2.0
 bsdiff4>=1.2.4
 platformdirs>=4.0.0
 certifi>=2023.11.17
-cython>=3.0.6
+cython>=3.0.5
 cymem>=2.0.8
 orjson>=3.9.10

settings.py

@@ -597,8 +597,8 @@ class ServerOptions(Group):
     disable_item_cheat: Union[DisableItemCheat, bool] = False
     location_check_points: LocationCheckPoints = LocationCheckPoints(1)
     hint_cost: HintCost = HintCost(10)
-    release_mode: ReleaseMode = ReleaseMode("auto")
-    collect_mode: CollectMode = CollectMode("auto")
+    release_mode: ReleaseMode = ReleaseMode("goal")
+    collect_mode: CollectMode = CollectMode("goal")
     remaining_mode: RemainingMode = RemainingMode("goal")
     auto_shutdown: AutoShutdown = AutoShutdown(0)
     compatibility: Compatibility = Compatibility(2)
@@ -673,7 +673,7 @@ class GeneratorOptions(Group):
     spoiler: Spoiler = Spoiler(3)
     glitch_triforce_room: GlitchTriforceRoom = GlitchTriforceRoom(1)  # why is this here?
     race: Race = Race(0)
-    plando_options: PlandoOptions = PlandoOptions("bosses, connections, texts")
+    plando_options: PlandoOptions = PlandoOptions("bosses")
 
 
 class SNIOptions(Group):

setup.py

@@ -54,6 +54,7 @@ if __name__ == "__main__":
     # TODO: move stuff to not require this
     import ModuleUpdate
     ModuleUpdate.update(yes="--yes" in sys.argv or "-y" in sys.argv)
+    ModuleUpdate.update_ran = False  # restore for later
 
 from worlds.LauncherComponents import components, icon_paths
 from Utils import version_tuple, is_windows, is_linux
@@ -75,6 +76,7 @@ non_apworlds: set = {
     "Ocarina of Time",
     "Overcooked! 2",
     "Raft",
+    "Secret of Evermore",
     "Slay the Spire",
     "Sudoku",
     "Super Mario 64",
@@ -303,6 +305,7 @@ class BuildExeCommand(cx_Freeze.command.build_exe.BuildEXE):
         print(f"Outputting to: {self.buildfolder}")
         os.makedirs(self.buildfolder, exist_ok=True)
         import ModuleUpdate
+        ModuleUpdate.requirements_files.add(os.path.join("WebHostLib", "requirements.txt"))
         ModuleUpdate.update(yes=self.yes)
 
         # auto-build cython modules
@@ -349,18 +352,6 @@ class BuildExeCommand(cx_Freeze.command.build_exe.BuildEXE):
             for folder in sdl2.dep_bins + glew.dep_bins:
                 shutil.copytree(folder, self.libfolder, dirs_exist_ok=True)
                 print(f"copying {folder} -> {self.libfolder}")
-            # windows needs Visual Studio C++ Redistributable
-            # Installer works for x64 and arm64
-            print("Downloading VC Redist")
-            import certifi
-            import ssl
-            context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH, cafile=certifi.where())
-            with urllib.request.urlopen(r"https://aka.ms/vs/17/release/vc_redist.x64.exe",
-                                        context=context) as download:
-                vc_redist = download.read()
-            print(f"Download complete, {len(vc_redist) / 1024 / 1024:.2f} MBytes downloaded.", )
-            with open("VC_redist.x64.exe", "wb") as vc_file:
-                vc_file.write(vc_redist)
 
         for data in self.extra_data:
             self.installfile(Path(data))

test/bases.py

@@ -285,7 +285,7 @@ class WorldTestBase(unittest.TestCase):
         if not (self.run_default_tests and self.constructed):
             return
         with self.subTest("Game", game=self.game):
-            excluded = self.multiworld.worlds[1].options.exclude_locations.value
+            excluded = self.multiworld.exclude_locations[1].value
             state = self.multiworld.get_all_state(False)
             for location in self.multiworld.get_locations():
                 if location.name not in excluded:

test/benchmark/__init__.py

@@ -1,127 +0,0 @@
-import time
-
-
-class TimeIt:
-    def __init__(self, name: str, time_logger=None):
-        self.name = name
-        self.logger = time_logger
-        self.timer = None
-        self.end_timer = None
-
-    def __enter__(self):
-        self.timer = time.perf_counter()
-        return self
-
-    @property
-    def dif(self):
-        return self.end_timer - self.timer
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if not self.end_timer:
-            self.end_timer = time.perf_counter()
-        if self.logger:
-            self.logger.info(f"{self.dif:.4f} seconds in {self.name}.")
-
-
-if __name__ == "__main__":
-    import argparse
-    import logging
-    import gc
-    import collections
-    import typing
-
-    # makes this module runnable from its folder.
-    import sys
-    import os
-    sys.path.remove(os.path.dirname(__file__))
-    new_home = os.path.normpath(os.path.join(os.path.dirname(__file__), os.pardir, os.pardir))
-    os.chdir(new_home)
-    sys.path.append(new_home)
-
-    from Utils import init_logging, local_path
-    local_path.cached_path = new_home
-    from BaseClasses import MultiWorld, CollectionState, Location
-    from worlds import AutoWorld
-    from worlds.AutoWorld import call_all
-
-    init_logging("Benchmark Runner")
-    logger = logging.getLogger("Benchmark")
-
-
-    class BenchmarkRunner:
-        gen_steps: typing.Tuple[str, ...] = (
-            "generate_early", "create_regions", "create_items", "set_rules", "generate_basic", "pre_fill")
-        rule_iterations: int = 100_000
-
-        if sys.version_info >= (3, 9):
-            @staticmethod
-            def format_times_from_counter(counter: collections.Counter[str], top: int = 5) -> str:
-                return "\n".join(f"  {time:.4f} in {name}" for name, time in counter.most_common(top))
-        else:
-            @staticmethod
-            def format_times_from_counter(counter: collections.Counter, top: int = 5) -> str:
-                return "\n".join(f"  {time:.4f} in {name}" for name, time in counter.most_common(top))
-
-        def location_test(self, test_location: Location, state: CollectionState, state_name: str) -> float:
-            with TimeIt(f"{test_location.game} {self.rule_iterations} "
-                        f"runs of {test_location}.access_rule({state_name})", logger) as t:
-                for _ in range(self.rule_iterations):
-                    test_location.access_rule(state)
-                # if time is taken to disentangle complex ref chains,
-                # this time should be attributed to the rule.
-                gc.collect()
-            return t.dif
-
-        def main(self):
-            for game in sorted(AutoWorld.AutoWorldRegister.world_types):
-                summary_data: typing.Dict[str, collections.Counter[str]] = {
-                    "empty_state": collections.Counter(),
-                    "all_state": collections.Counter(),
-                }
-                try:
-                    multiworld = MultiWorld(1)
-                    multiworld.game[1] = game
-                    multiworld.player_name = {1: "Tester"}
-                    multiworld.set_seed(0)
-                    multiworld.state = CollectionState(multiworld)
-                    args = argparse.Namespace()
-                    for name, option in AutoWorld.AutoWorldRegister.world_types[game].options_dataclass.type_hints.items():
-                        setattr(args, name, {
-                            1: option.from_any(getattr(option, "default"))
-                        })
-                    multiworld.set_options(args)
-
-                    gc.collect()
-                    for step in self.gen_steps:
-                        with TimeIt(f"{game} step {step}", logger):
-                            call_all(multiworld, step)
-                            gc.collect()
-
-                    locations = sorted(multiworld.get_unfilled_locations())
-                    if not locations:
-                        continue
-
-                    all_state = multiworld.get_all_state(False)
-                    for location in locations:
-                        time_taken = self.location_test(location, multiworld.state, "empty_state")
-                        summary_data["empty_state"][location.name] = time_taken
-
-                        time_taken = self.location_test(location, all_state, "all_state")
-                        summary_data["all_state"][location.name] = time_taken
-
-                    total_empty_state = sum(summary_data["empty_state"].values())
-                    total_all_state = sum(summary_data["all_state"].values())
-
-                    logger.info(f"{game} took {total_empty_state/len(locations):.4f} "
-                                f"seconds per location in empty_state and {total_all_state/len(locations):.4f} "
-                                f"in all_state. (all times summed for {self.rule_iterations} runs.)")
-                    logger.info(f"Top times in empty_state:\n"
-                                f"{self.format_times_from_counter(summary_data['empty_state'])}")
-                    logger.info(f"Top times in all_state:\n"
-                                f"{self.format_times_from_counter(summary_data['all_state'])}")
-
-                except Exception as e:
-                    logger.exception(e)
-
-    runner = BenchmarkRunner()
-    runner.main()

test/general/test_ids.py

@@ -1,8 +1,5 @@
 import unittest
-
-from Fill import distribute_items_restrictive
-from worlds.AutoWorld import AutoWorldRegister, call_all
-from . import setup_solo_multiworld
+from worlds.AutoWorld import AutoWorldRegister
 
 
 class TestIDs(unittest.TestCase):
@@ -69,34 +66,3 @@ class TestIDs(unittest.TestCase):
         for gamename, world_type in AutoWorldRegister.world_types.items():
             with self.subTest(game=gamename):
                 self.assertEqual(len(world_type.location_id_to_name), len(world_type.location_name_to_id))
-
-    def test_postgen_datapackage(self):
-        """Generates a solo multiworld and checks that the datapackage is still valid"""
-        for gamename, world_type in AutoWorldRegister.world_types.items():
-            with self.subTest(game=gamename):
-                multiworld = setup_solo_multiworld(world_type)
-                distribute_items_restrictive(multiworld)
-                call_all(multiworld, "post_fill")
-                datapackage = world_type.get_data_package_data()
-                for item_group, item_names in datapackage["item_name_groups"].items():
-                    self.assertIsInstance(item_group, str,
-                                          f"item_name_group names should be strings: {item_group}")
-                    for item_name in item_names:
-                        self.assertIsInstance(item_name, str,
-                                              f"{item_name}, in group {item_group} is not a string")
-                for loc_group, loc_names in datapackage["location_name_groups"].items():
-                    self.assertIsInstance(loc_group, str,
-                                          f"location_name_group names should be strings: {loc_group}")
-                    for loc_name in loc_names:
-                        self.assertIsInstance(loc_name, str,
-                                              f"{loc_name}, in group {loc_group} is not a string")
-                for item_name, item_id in datapackage["item_name_to_id"].items():
-                    self.assertIsInstance(item_name, str,
-                                          f"{item_name} is not a valid item name for item_name_to_id")
-                    self.assertIsInstance(item_id, int,
-                                          f"{item_id} for {item_name} should be an int")
-                for loc_name, loc_id in datapackage["location_name_to_id"].items():
-                    self.assertIsInstance(loc_name, str,
-                                          f"{loc_name} is not a valid item name for location_name_to_id")
-                    self.assertIsInstance(loc_id, int,
-                                          f"{loc_id} for {loc_name} should be an int")

test/general/test_items.py

@@ -1,6 +1,5 @@
 import unittest
-
-from worlds.AutoWorld import AutoWorldRegister, call_all
+from worlds.AutoWorld import AutoWorldRegister
 from . import setup_solo_multiworld
 
 
@@ -54,7 +53,7 @@ class TestBase(unittest.TestCase):
                     f"{game_name} Item count MUST meet or exceed the number of locations",
                 )
 
-    def test_items_in_datapackage(self):
+    def testItemsInDatapackage(self):
         """Test that any created items in the itempool are in the datapackage"""
         for game_name, world_type in AutoWorldRegister.world_types.items():
             with self.subTest("Game", game=game_name):
@@ -70,20 +69,3 @@ class TestBase(unittest.TestCase):
                 with self.subTest("Name should be valid", game=game_name, item=name):
                     self.assertIn(name, valid_names,
                                   "All item descriptions must match defined item names")
-
-    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")
-        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}
-        for game_name, world_type in worlds_to_test.items():
-            with self.subTest("Game", game=game_name):
-                multiworld = setup_solo_multiworld(world_type, gen_steps)
-                created_items = multiworld.itempool.copy()
-                for step in additional_steps:
-                    with self.subTest("step", step=step):
-                        call_all(multiworld, step)
-                        self.assertEqual(created_items, multiworld.itempool,
-                                         f"{game_name} modified the itempool during {step}")

test/general/test_options.py

@@ -10,10 +10,3 @@ class TestOptions(unittest.TestCase):
                 for option_key, option in world_type.options_dataclass.type_hints.items():
                     with self.subTest(game=gamename, option=option_key):
                         self.assertTrue(option.__doc__)
-
-    def test_options_are_not_set_by_world(self):
-        """Test that options attribute is not already set"""
-        for gamename, world_type in AutoWorldRegister.world_types.items():
-            with self.subTest(game=gamename):
-                self.assertFalse(hasattr(world_type, "options"),
-                                 f"Unexpected assignment to {world_type.__name__}.options!")

test/general/test_reachability.py

@@ -37,7 +37,7 @@ class TestBase(unittest.TestCase):
             unreachable_regions = self.default_settings_unreachable_regions.get(game_name, set())
             with self.subTest("Game", game=game_name):
                 world = setup_solo_multiworld(world_type)
-                excluded = world.worlds[1].options.exclude_locations.value
+                excluded = world.exclude_locations[1].value
                 state = world.get_all_state(False)
                 for location in world.get_locations():
                     if location.name not in excluded:

test/webhost/test_api_generate.py

@@ -1,7 +1,5 @@
-import io
 import unittest
 import json
-import yaml
 
 
 class TestDocs(unittest.TestCase):
@@ -25,7 +23,7 @@ class TestDocs(unittest.TestCase):
         response = self.client.post("/api/generate")
         self.assertIn("No options found. Expected file attachment or json weights.", response.text)
 
-    def test_generation_queued_weights(self):
+    def test_generation_queued(self):
         options = {
             "Tester1":
                 {
@@ -42,19 +40,3 @@ class TestDocs(unittest.TestCase):
         json_data = response.get_json()
         self.assertTrue(json_data["text"].startswith("Generation of seed "))
         self.assertTrue(json_data["text"].endswith(" started successfully."))
-
-    def test_generation_queued_file(self):
-        options = {
-            "game": "Archipelago",
-            "name": "Tester",
-            "Archipelago": {}
-        }
-        response = self.client.post(
-            "/api/generate",
-            data={
-                'file': (io.BytesIO(yaml.dump(options, encoding="utf-8")), "test.yaml")
-            },
-        )
-        json_data = response.get_json()
-        self.assertTrue(json_data["text"].startswith("Generation of seed "))
-        self.assertTrue(json_data["text"].endswith(" started successfully."))

typings/kivy/graphics.pyi

@@ -1,12 +1,24 @@
-from .texture import FillType_Drawable, FillType_Vec, Texture
+""" FillType_* is not a real kivy type - just something to fill unknown typing. """
+
+from typing import Sequence
+
+FillType_Vec = Sequence[int]
+
+
+class FillType_Drawable:
+    def __init__(self, *, pos: FillType_Vec = ..., size: FillType_Vec = ...) -> None: ...
+
+
+class FillType_Texture(FillType_Drawable):
+    pass
 
 
 class FillType_Shape(FillType_Drawable):
-    texture: Texture
+    texture: FillType_Texture
 
     def __init__(self,
                  *,
-                 texture: Texture = ...,
+                 texture: FillType_Texture = ...,
                  pos: FillType_Vec = ...,
                  size: FillType_Vec = ...) -> None: ...
 
@@ -23,6 +35,6 @@ class Rectangle(FillType_Shape):
     def __init__(self,
                  *,
                  source: str = ...,
-                 texture: Texture = ...,
+                 texture: FillType_Texture = ...,
                  pos: FillType_Vec = ...,
                  size: FillType_Vec = ...) -> None: ...

typings/kivy/graphics/texture.pyi

@@ -1,13 +0,0 @@
-""" FillType_* is not a real kivy type - just something to fill unknown typing. """
-
-from typing import Sequence
-
-FillType_Vec = Sequence[int]
-
-
-class FillType_Drawable:
-    def __init__(self, *, pos: FillType_Vec = ..., size: FillType_Vec = ...) -> None: ...
-
-
-class Texture:
-    pass

typings/kivy/uix/image.pyi

@@ -1,9 +0,0 @@
-import io
-
-from kivy.graphics.texture import Texture
-
-
-class CoreImage:
-    texture: Texture
-
-    def __init__(self, data: io.BytesIO, ext: str) -> None: ...

worlds/AutoWorld.py

@@ -77,10 +77,6 @@ class AutoWorldRegister(type):
         # create missing options_dataclass from legacy option_definitions
         # TODO - remove this once all worlds use options dataclasses
         if "options_dataclass" not in dct and "option_definitions" in dct:
-            # TODO - switch to deprecate after a version
-            if __debug__:
-                logging.warning(f"{name} Assigned options through option_definitions which is now deprecated. "
-                                "Please use options_dataclass instead.")
             dct["options_dataclass"] = make_dataclass(f"{name}Options", dct["option_definitions"].items(),
                                                       bases=(PerGameCommonOptions,))
 
@@ -328,7 +324,7 @@ class World(metaclass=AutoWorldRegister):
 
     def create_items(self) -> None:
         """
-        Method for creating and submitting items to the itempool. Items and Regions must *not* be created and submitted
+        Method for creating and submitting items to the itempool. Items and Regions should *not* be created and submitted
         to the MultiWorld after this step. If items need to be placed during pre_fill use `get_prefill_items`.
         """
         pass

worlds/_bizhawk/__init__.py

@@ -97,7 +97,7 @@ async def connect(ctx: BizHawkContext) -> bool:
 
     for port in ports:
         try:
-            ctx.streams = await asyncio.open_connection("127.0.0.1", port)
+            ctx.streams = await asyncio.open_connection("localhost", port)
             ctx.connection_status = ConnectionStatus.TENTATIVE
             ctx._port = port
             return True

worlds/_bizhawk/context.py

@@ -208,30 +208,19 @@ async def _run_game(rom: str):
 
     if auto_start is True:
         emuhawk_path = Utils.get_settings().bizhawkclient_options.emuhawk_path
-        subprocess.Popen(
-            [
-                emuhawk_path,
-                f"--lua={Utils.local_path('data', 'lua', 'connector_bizhawk_generic.lua')}",
-                os.path.realpath(rom),
-            ],
-            cwd=Utils.local_path("."),
-            stdin=subprocess.DEVNULL,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-        )
+        subprocess.Popen([emuhawk_path, "--lua=data/lua/connector_bizhawk_generic.lua", os.path.realpath(rom)],
+                         cwd=Utils.local_path("."),
+                         stdin=subprocess.DEVNULL,
+                         stdout=subprocess.DEVNULL,
+                         stderr=subprocess.DEVNULL)
     elif isinstance(auto_start, str):
         import shlex
 
-        subprocess.Popen(
-            [
-                *shlex.split(auto_start),
-                os.path.realpath(rom)
-            ],
-            cwd=Utils.local_path("."),
-            stdin=subprocess.DEVNULL,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL
-        )
+        subprocess.Popen([*shlex.split(auto_start), os.path.realpath(rom)],
+                         cwd=Utils.local_path("."),
+                         stdin=subprocess.DEVNULL,
+                         stdout=subprocess.DEVNULL,
+                         stderr=subprocess.DEVNULL)
 
 
 async def _patch_and_run_game(patch_file: str):

worlds/adventure/docs/setup_en.md

@@ -10,7 +10,8 @@ As we are using BizHawk, this guide is only applicable to Windows and Linux syst
   - Version 2.3.1 and later are supported. Version 2.7 is recommended for stability.
   - Detailed installation instructions for BizHawk can be found at the above link.
   - Windows users must run the prereq installer first, which can also be found at the above link.
-- The built-in Archipelago client, which can be installed [here](https://github.com/ArchipelagoMW/Archipelago/releases).
+- The built-in Archipelago client, which can be installed [here](https://github.com/ArchipelagoMW/Archipelago/releases)
+  (select `Adventure Client` during installation).
 - An Adventure NTSC ROM file. The Archipelago community cannot provide these.
 
 ## Configuring BizHawk

worlds/alttp/Dungeons.py

@@ -264,7 +264,7 @@ def fill_dungeons_restrictive(multiworld: MultiWorld):
 
                         if loc in all_state_base.events:
                             all_state_base.events.remove(loc)
-            fill_restrictive(multiworld, all_state_base, locations, in_dungeon_items, True, True, allow_excluded=True,
+            fill_restrictive(multiworld, all_state_base, locations, in_dungeon_items, True, True,
                              name="LttP Dungeon Items")
 
 

worlds/alttp/ItemPool.py

@@ -682,6 +682,8 @@ def get_pool_core(world, player: int):
                 key_location = world.random.choice(key_locations)
                 place_item(key_location, "Small Key (Universal)")
                 pool = pool[:-3]
+        if world.key_drop_shuffle[player]:
+            pass # pool.extend([item_to_place] * (len(key_drop_data) - 1))
 
     return (pool, placed_items, precollected_items, clock_mode, treasure_hunt_count, treasure_hunt_icon,
             additional_pieces_to_place)

worlds/alttp/Options.py

@@ -1,7 +1,8 @@
 import typing
 
 from BaseClasses import MultiWorld
-from Options import Choice, Range, Option, Toggle, DefaultOnToggle, DeathLink, StartInventoryPool, PlandoBosses
+from Options import Choice, Range, Option, Toggle, DefaultOnToggle, DeathLink, AllowCollect, StartInventoryPool, \
+    PlandoBosses
 
 
 class Logic(Choice):
@@ -426,12 +427,6 @@ class BeemizerTrapChance(BeemizerRange):
     display_name = "Beemizer Trap Chance"
 
 
-class AllowCollect(Toggle):
-    """Allows for !collect / co-op to auto-open chests containing items for other players.
-    Off by default, because it currently crashes on real hardware."""
-    display_name = "Allow Collection of checks for other players"
-
-
 alttp_options: typing.Dict[str, type(Option)] = {
     "crystals_needed_for_gt": CrystalsTower,
     "crystals_needed_for_ganon": CrystalsGanon,

worlds/alttp/Rules.py

@@ -136,8 +136,7 @@ def mirrorless_path_to_castle_courtyard(world, player):
 
 def set_defeat_dungeon_boss_rule(location):
     # Lambda required to defer evaluation of dungeon.boss since it will change later if boss shuffle is used
-    add_rule(location, lambda state: location.parent_region.dungeon.boss.can_defeat(state))
-
+    set_rule(location, lambda state: location.parent_region.dungeon.boss.can_defeat(state))
 
 def set_always_allow(spot, rule):
     spot.always_allow = rule

worlds/alttp/SubClasses.py

@@ -26,13 +26,6 @@ class ALttPLocation(Location):
         self.player_address = player_address
         self._hint_text = hint_text
 
-    @property
-    def hint_text(self) -> str:
-        hint_text = getattr(self, "_hint_text", None)
-        if hint_text:
-            return hint_text
-        return "at " + self.name.replace("_", " ").replace("-", " ")
-
 
 class ALttPItem(Item):
     game: str = "A Link to the Past"

worlds/alttp/__init__.py

@@ -289,17 +289,12 @@ class ALTTPWorld(World):
         self.waterfall_fairy_bottle_fill = self.random.choice(bottle_options)
         self.pyramid_fairy_bottle_fill = self.random.choice(bottle_options)
 
-        if multiworld.mode[player] == 'standard':
-            if multiworld.smallkey_shuffle[player]:
-                if (multiworld.smallkey_shuffle[player] not in
-                   (smallkey_shuffle.option_universal, smallkey_shuffle.option_own_dungeons,
-                    smallkey_shuffle.option_start_with)):
-                    self.multiworld.local_early_items[self.player]["Small Key (Hyrule Castle)"] = 1
-                self.multiworld.local_items[self.player].value.add("Small Key (Hyrule Castle)")
-                self.multiworld.non_local_items[self.player].value.discard("Small Key (Hyrule Castle)")
-            if multiworld.bigkey_shuffle[player]:
-                self.multiworld.local_items[self.player].value.add("Big Key (Hyrule Castle)")
-                self.multiworld.non_local_items[self.player].value.discard("Big Key (Hyrule Castle)")
+        if multiworld.mode[player] == 'standard' \
+                and multiworld.smallkey_shuffle[player] \
+                and multiworld.smallkey_shuffle[player] != smallkey_shuffle.option_universal \
+                and multiworld.smallkey_shuffle[player] != smallkey_shuffle.option_own_dungeons \
+                and multiworld.smallkey_shuffle[player] != smallkey_shuffle.option_start_with:
+            self.multiworld.local_early_items[self.player]["Small Key (Hyrule Castle)"] = 1
 
         # system for sharing ER layouts
         self.er_seed = str(multiworld.random.randint(0, 2 ** 64))

worlds/alttp/docs/multiworld_en.md

@@ -2,7 +2,8 @@
 
 ## Required Software
 
-- [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases).
+- [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases). Make sure to check the box for
+`SNI Client - A Link to the Past Patch Setup`
 - [SNI](https://github.com/alttpo/sni/releases). This is automatically included with your Archipelago installation above.
 - SNI is not compatible with (Q)Usb2Snes.
 - Hardware or software capable of loading and playing SNES ROM files
@@ -17,12 +18,11 @@ but it is not supported.**
 
 ## Installation Procedures
 
-1. Download and install [Archipelago](<https://github.com/ArchipelagoMW/Archipelago/releases/latest>). **The installer 
-   file is located in the assets section at the bottom of the version information.**
-2. The first time you do local generation or patch your game, you will be asked to locate your base ROM file.
-   This is your Japanese Link to the Past ROM file. This only needs to be done once.
+1. Download and install SNIClient from the link above, making sure to install the most recent version.
+   **The installer file is located in the assets section at the bottom of the version information**.
+    - During setup, you will be asked to locate your base ROM file. This is your Japanese Link to the Past ROM file.
 
-3. If you are using an emulator, you should assign your Lua capable emulator as your default program for launching ROM
+2. If you are using an emulator, you should assign your Lua capable emulator as your default program for launching ROM
    files.
     1. Extract your emulator's folder to your Desktop, or somewhere you will remember.
     2. Right-click on a ROM file and select **Open with...**

worlds/bk_sudoku/__init__.py

@@ -7,25 +7,16 @@ from ..AutoWorld import WebWorld, World
 class Bk_SudokuWebWorld(WebWorld):
     options_page = "games/Sudoku/info/en"
     theme = 'partyTime'
-
-    setup_en = Tutorial(
-        tutorial_name='Setup Guide',
-        description='A guide to playing BK Sudoku',
-        language='English',
-        file_name='setup_en.md',
-        link='setup/en',
-        authors=['Jarno']
-    )
-    setup_de = Tutorial(
-        tutorial_name='Setup Anleitung',
-        description='Eine Anleitung um BK-Sudoku zu spielen',
-        language='Deutsch',
-        file_name='setup_de.md',
-        link='setup/de',
-        authors=['Held_der_Zeit']
-    )
-    
-    tutorials = [setup_en, setup_de]
+    tutorials = [
+        Tutorial(
+            tutorial_name='Setup Guide',
+            description='A guide to playing BK Sudoku',
+            language='English',
+            file_name='setup_en.md',
+            link='setup/en',
+            authors=['Jarno']
+        )
+    ]
 
 
 class Bk_SudokuWorld(World):

worlds/bk_sudoku/docs/de_Sudoku.md

@@ -1,21 +0,0 @@
-# BK-Sudoku
-
-## Was ist das für ein Spiel?
-
-BK-Sudoku ist kein typisches Archipelago-Spiel; stattdessen ist es ein gewöhnlicher Sudoku-Client der sich zu jeder
-beliebigen Multiworld verbinden kann. Einmal verbunden kannst du ein 9x9 Sudoku spielen um einen zufälligen Hinweis
-für dein Spiel zu erhalten. Es ist zwar langsam, aber es gibt dir etwas zu tun, solltest du mal nicht in der Lage sein
-weitere „Checks” zu erreichen.
-(Wer mag kann auch einfach so Sudoku spielen. Man muss nicht mit einer Multiworld verbunden sein, um ein Sudoku zu
-spielen/generieren.)
-
-## Wie werden Hinweise freigeschalten?
-
-Nach dem Lösen eines Sudokus wird für den verbundenen Slot ein zufällig ausgewählter Hinweis freigegeben, für einen
-Gegenstand der noch nicht gefunden wurde.
-
-## Wo ist die Seite für die Einstellungen?
-
-Es gibt keine Seite für die Einstellungen. Dieses Spiel kann nicht in deinen YAML-Dateien benutzt werden. Stattdessen
-kann sich der Client mit einem beliebigen Slot einer Multiworld verbinden. In dem Client selbst kann aber der
-Schwierigkeitsgrad des Sudoku ausgewählt werden.

worlds/bk_sudoku/docs/setup_de.md

@@ -1,27 +0,0 @@
-# BK-Sudoku Setup Anleitung
-
-## Benötigte Software
-- [Bk-Sudoku](https://github.com/Jarno458/sudoku)
-- Windows 8 oder höher
-
-## Generelles Konzept
-
-Dies ist ein Client, der sich mit jedem beliebigen Slot einer Multiworld verbinden kann. Er lässt dich ein (9x9) Sudoku
-spielen, um zufällige Hinweise für den verbundenen Slot freizuschalten.
-
-Aufgrund des Fakts, dass der Sudoku-Client sich zu jedem beliebigen Slot verbinden kann, ist es daher nicht notwendig
-eine YAML für dieses Spiel zu generieren, da es keinen neuen Slot zur Multiworld-Session hinzufügt.
-
-## Installationsprozess
-
-Gehe zu der aktuellsten (latest) Veröffentlichung der [BK-Sudoku Releases](https://github.com/Jarno458/sudoku/releases).
-Downloade und extrahiere/entpacke die `Bk_Sudoku.zip`-Datei.
-
-## Verbinden mit einer Multiworld
-
-1. Starte `Bk_Sudoku.exe`
-2. Trage den Namen des Slots ein, mit dem du dich verbinden möchtest
-3. Trage die Server-URL und den Port ein
-4. Drücke auf Verbinden (connect)
-5. Wähle deinen Schwierigkeitsgrad
-6. Versuche das Sudoku zu Lösen

worlds/checksfinder/docs/setup_en.md

@@ -5,6 +5,7 @@
 - ChecksFinder from
   the [Github releases Page for the game](https://github.com/jonloveslegos/ChecksFinder/releases) (latest version)
 - Archipelago from the [Archipelago Releases Page](https://github.com/ArchipelagoMW/Archipelago/releases)
+    - (select `ChecksFinder Client` during installation.)
 
 ## Configuring your YAML file
 

worlds/clique/__init__.py

@@ -11,26 +11,16 @@ from .Rules import get_button_rule
 
 class CliqueWebWorld(WebWorld):
     theme = "partyTime"
-    
-    setup_en = Tutorial(
-        tutorial_name="Start Guide",
-        description="A guide to playing Clique.",
-        language="English",
-        file_name="guide_en.md",
-        link="guide/en",
-        authors=["Phar"]
-    )
-
-    setup_de = Tutorial(
-        tutorial_name="Anleitung zum Anfangen",
-        description="Eine Anleitung um Clique zu spielen.",
-        language="Deutsch",
-        file_name="guide_de.md",
-        link="guide/de",
-        authors=["Held_der_Zeit"]
-    )
-    
-    tutorials = [setup_en, setup_de]
+    tutorials = [
+        Tutorial(
+            tutorial_name="Start Guide",
+            description="A guide to playing Clique.",
+            language="English",
+            file_name="guide_en.md",
+            link="guide/en",
+            authors=["Phar"]
+        )
+    ]
 
 
 class CliqueWorld(World):

worlds/clique/docs/de_Clique.md

@@ -1,18 +0,0 @@
-# Clique
-
-## Was ist das für ein Spiel?
-
-~~Clique ist ein psychologisches Überlebens-Horror Spiel, in dem der Spieler der Versuchung wiederstehen muss große~~
-~~(rote) Knöpfe zu drücken.~~
-
-Clique ist ein scherzhaftes Spiel, welches für Archipelago im März 2023 entwickelt wurde, um zu zeigen, wie einfach
-es sein kann eine Welt für Archipelago zu entwicklen. Das Ziel des Spiels ist es den großen (standardmäßig) roten
-Knopf zu drücken. Wenn ein Spieler auf dem `hard_mode` (schwieriger Modus) spielt, muss dieser warten bis jemand
-anderes in der Multiworld den Knopf aktiviert, damit er gedrückt werden kann.
-
-Clique kann auf den meisten modernen, HTML5-fähigen Browsern gespielt werden.
-
-## Wo ist die Seite für die Einstellungen?
-
-Die [Seite für die Spielereinstellungen dieses Spiels](../player-options) enthält alle Optionen die man benötigt um
-eine YAML-Datei zu konfigurieren und zu exportieren.

worlds/clique/docs/guide_de.md

@@ -1,25 +0,0 @@
-# Clique Anleitung
-
-Nachdem dein Seed generiert wurde, gehe auf die Website von [Clique dem Spiel](http://clique.pharware.com/) und gib
-Server-Daten, deinen Slot-Namen und ein Passwort (falls vorhanden) ein. Klicke dann auf "Connect" (Verbinden).
-
-Wenn du auf "Einfach" spielst, kannst du unbedenklich den Knopf drücken und deine "Befriedigung" erhalten.
-
-Wenn du auf "Schwer" spielst, ist es sehr wahrscheinlich, dass du warten musst bevor du dein Ziel erreichen kannst.
-Glücklicherweise läuft Click auf den meißten großen Browsern, die HTML5 unterstützen. Das heißt du kannst Clique auf
-deinem Handy starten und produktiv sein während du wartest!
-
-Falls du einige Ideen brauchst was du tun kannst, während du wartest bis der Knopf aktiviert wurde, versuche
-(mindestens) eins der Folgenden:
-
-- Dein Zimmer aufräumen.
-- Die Wäsche machen.
-- Etwas Essen von einem X-Belieben Fast Food Restaruant holen.
-- Das tägliche Wordle machen.
-- ~~Deine Seele an **Phar** verkaufen.~~
-- Deine Hausaufgaben erledigen.
-- Deine Post abholen.
-
-
-~~Solltest du auf irgendwelche Probleme in diesem Spiel stoßen, solltest du keinesfalls nicht **thephar** auf~~
-~~Discord kontaktieren. *zwinker* *zwinker*~~

worlds/dark_souls_3/docs/setup_en.md

@@ -21,20 +21,7 @@ This client has only been tested with the Official Steam version of the game at
 
 ## Downpatching Dark Souls III
 
-To downpatch DS3 for use with Archipelago, use the following instructions from the speedsouls wiki database. 
-
-1. Launch Steam (in online mode).
-2. Press the Windows Key + R. This will open the Run window.
-3. Open the Steam console by typing the following string: steam://open/console , Steam should now open in Console Mode.
-4. Insert the string of the depot you wish to download. For the AP supported v1.15, you will want to use: download_depot 374320 374321 4471176929659548333.
-5. Steam will now download the depot. Note: There is no progress bar of the download in Steam, but it is still downloading in the background.
-6. Turn off auto-updates in Steam by right-clicking Dark Souls III in your library > Properties > Updates > set "Automatic Updates" to "Only update this game when I launch it" (or change the value for AutoUpdateBehavior to 1 in "\Steam\steamapps\appmanifest_374320.acf").
-7. Back up your existing game folder in "\Steam\steamapps\common\DARK SOULS III".
-8. Return back to Steam console. Once the download is complete, it should say so along with the temporary local directory in which the depot has been stored. This is usually something like "\Steam\steamapps\content\app_XXXXXX\depot_XXXXXX". Back up this game folder as well.
-9. Delete your existing game folder in "\Steam\steamapps\common\DARK SOULS III", then replace it with your game folder in "\Steam\steamapps\content\app_XXXXXX\depot_XXXXXX".
-10. Back up and delete your save file "DS30000.sl2" in AppData. AppData is hidden by default. To locate it, press Windows Key + R, type %appdata% and hit enter or: open File Explorer > View > Hidden Items and follow "C:\Users\your username\AppData\Roaming\DarkSoulsIII\numbers".
-11. If you did all these steps correctly, you should be able to confirm your game version in the upper left corner after launching Dark Souls III.
-
+Follow instructions from the [speedsouls wiki](https://wiki.speedsouls.com/darksouls3:Downpatching) to download version 1.15. Your download command, including the correct depot and manifest ids, will be "download_depot 374320 374321 4471176929659548333"
 
 ## Installing the Archipelago mod
 

worlds/dkc3/docs/setup_en.md

@@ -2,7 +2,7 @@
 
 ## Required Software
 
-- [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases).
+- [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases). Make sure to check the box for `SNI Client - Donkey Kong Country 3 Patch Setup`
 
 
 - Hardware or software capable of loading and playing SNES ROM files
@@ -23,10 +23,9 @@
 
 ### Windows Setup
 
-1. Download and install [Archipelago](<https://github.com/ArchipelagoMW/Archipelago/releases/latest>). **The installer 
-   file is located in the assets section at the bottom of the version information.**
-2. The first time you do local generation or patch your game, you will be asked to locate your base ROM file.
-   This is your Donkey Kong Country 3 ROM file. This only needs to be done once.
+1. During the installation of Archipelago, you will have been asked to install the SNI Client. If you did not do this,
+   or you are on an older version, you may run the installer again to install the SNI Client.
+2. During setup, you will be asked to locate your base ROM file. This is your Donkey Kong Country 3 ROM file.
 3. If you are using an emulator, you should assign your Lua capable emulator as your default program for launching ROM
    files.
     1. Extract your emulator's folder to your Desktop, or somewhere you will remember.

worlds/dlcquest/__init__.py

@@ -13,23 +13,14 @@ client_version = 0
 
 
 class DLCqwebworld(WebWorld):
-    setup_en = Tutorial(
+    tutorials = [Tutorial(
         "Multiworld Setup Tutorial",
         "A guide to setting up the Archipelago DLCQuest game on your computer.",
         "English",
         "setup_en.md",
         "setup/en",
         ["axe_y"]
-    )
-    setup_fr = Tutorial(
-        "Guide de configuration MultiWorld",
-        "Un guide pour configurer DLCQuest sur votre PC.",
-        "Français",
-        "setup_fr.md",
-        "setup/fr",
-        ["Deoxis"]
-    )
-    tutorials = [setup_en, setup_fr]
+    )]
 
 
 class DLCqworld(World):

worlds/dlcquest/docs/fr_DLCQuest.md

@@ -1,49 +0,0 @@
-# DLC Quest
-
-## Où se trouve la page des paramètres ?
-
-La [page des paramètres du joueur pour ce jeu](../player-settings) contient tous les paramètres dont vous avez besoin pour configurer et exporter le fichier.
-
-
-## Quel est l'effet de la randomisation sur ce jeu ?
-
-Les DLC seront obtenus en tant que check pour le multiworld. Il existe également d'autres checks optionnels dans DLC Quest.
-
-## Quel est le but de DLC Quest ?
-
-DLC Quest a deux campagnes, et le joueur peut choisir celle qu'il veut jouer pour sa partie.
-Il peut également choisir de faire les deux campagnes.
-
-
-## Quels sont les emplacements dans DLC quest ?
-
-Les emplacements dans DLC Quest comprennent toujours
-- les achats de DLC auprès du commerçant
-- Les objectifs liés aux récompenses
-    - Tuer des moutons dans DLC Quest
-    - Objectifs spécifiques de l'attribution dans Live Freemium or Die
-
-Il existe également un certain nombres de critères de localisation qui sont optionnels et que les joueurs peuvent choisir d'inclure ou non dans leur sélection :
-- Objets que votre personnage peut obtenir de différentes manières
-    - Swords
-    - Gun
-    - Box of Various Supplies
-    - Humble Indie Bindle
-    - Pickaxe
-- Coinsanity : Pièces de monnaie, soit individuellement, soit sous forme de lots personnalisés
-
-## Quels objets peuvent se trouver dans le monde d'un autre joueur ?
-
-Tous les DLC du jeu sont mélangés dans le stock d'objets. Les objets liés aux contrôles optionnels décrits ci-dessus sont également dans le stock
-
-Il y a aussi de nouveaux objets pièges, utilisés comme substituts, basés sur les désagréments du jeu vanille.
-- Zombie Sheep
-- Loading Screens
-- Temporary Spikes
-
-## Que se passe-t-il lorsque le joueur reçoit un objet ?
-
-Chaque fois qu'un objet est reçu en ligne, une notification apparaît à l'écran pour en informer le joueur.
-Certains objets sont accompagnés d'une animation ou d'une scène qui se déroule immédiatement après leur réception.
-
-Les objets reçus hors ligne ne sont pas accompagnés d'une animation ou d'une scène, et sont simplement activés lors de la connexion.

worlds/dlcquest/docs/setup_fr.md

@@ -1,55 +0,0 @@
-# # Guide de configuration MultiWorld de DLCQuest
-
-## Logiciels requis
-
-- DLC Quest sur PC (Recommandé: [Version Steam](https://store.steampowered.com/app/230050/DLC_Quest/))
-- [DLCQuestipelago](https://github.com/agilbert1412/DLCQuestipelago/releases)
-- BepinEx (utilisé comme un modloader pour DLCQuest. La version du mod ci-dessus inclut BepInEx si vous choisissez la version d'installation complète)
-
-## Logiciels optionnels
-- [Archipelago] (https://github.com/ArchipelagoMW/Archipelago/releases)
-    - (Uniquement pour le TextClient)
-
-## Créer un fichier de configuration (.yaml)
-
-### Qu'est-ce qu'un fichier YAML et pourquoi en ai-je besoin ?
-
-Voir le guide d'Archipelago sur la mise en place d'un YAML de base : [Basic Multiworld Setup Guide](/tutorial/Archipelago/setup/en)
-
-### Où puis-je obtenir un fichier YAML ?
-
-Vous pouvez personnaliser vos paramètres en visitant la [page des paramètres du joueur DLC Quest] (/games/DLCQuest/player-settings).
-
-## Rejoindre une partie multi-monde
-
-### Installer le mod
-
-- Télécharger le [DLCQuestipelago mod release](https://github.com/agilbert1412/DLCQuestipelago/releases). Si c'est la première fois que vous installez le mod, ou si vous n'êtes pas à l'aise avec l'édition manuelle de fichiers, vous devriez choisir l'Installateur. Il se chargera de la plus grande partie du travail pour vous
-
-
-- Extraire l'archive .zip à l'emplacement de votre choix
-
-
-- Exécutez "DLCQuestipelagoInstaller.exe".
-
-![image](https://i.imgur.com/2sPhMgs.png)
-- Le programme d'installation devrait décrire ce qu'il fait à chaque étape, et vous demandera votre avis si nécessaire.
-  - Il vous permettra de choisir l'emplacement d'installation de votre jeu moddé et vous proposera un emplacement par défaut
-  - Il **essayera** de trouver votre jeu DLCQuest sur votre ordinateur et, en cas d'échec, vous demandera d'indiquer le chemin d'accès.
-  - Il vous offrira la possibilité de créer un raccourci sur le bureau pour le lanceur moddé.
-
-### Se connecter au MultiServer
-
-- Localisez le fichier "ArchipelagoConnectionInfo.json", qui se situe dans le même emplacement que votre installation moddée. Vous pouvez éditer ce fichier avec n'importe quel éditeur de texte, et vous devez entrer l'adresse IP du serveur, le port et votre nom de joueur dans les champs appropriés.
-
-- Exécutez BepInEx.NET.Framework.Launcher.exe. Si vous avez opté pour un raccourci sur le bureau, vous le trouverez avec une icône et un nom plus reconnaissable.
-![image](https://i.imgur.com/ZUiFrhf.png)
-
-- Votre jeu devrait se lancer en même temps qu'une console de modloader, qui contiendra des informations de débogage importantes si vous rencontrez des problèmes.
-- Le jeu devrait se connecter automatiquement, et tenter de se reconnecter si votre internet ou le serveur se déconnecte, pendant que vous jouez.
-
-### Interagir avec le MultiWorld depuis le jeu
-
-Vous ne pouvez pas envoyer de commandes au serveur ou discuter avec les autres joueurs depuis DLC Quest, car le jeu ne dispose pas d'un moyen approprié pour saisir du texte.
-Vous pouvez suivre l'activité du serveur dans votre console BepInEx, car les messages de chat d'Archipelago y seront affichés.
-Vous devrez utiliser [Archipelago Text Client] (https://github.com/ArchipelagoMW/Archipelago/releases) si vous voulez envoyer des commandes.

worlds/factorio/Mod.py

@@ -5,7 +5,7 @@ import os
 import shutil
 import threading
 import zipfile
-from typing import Optional, TYPE_CHECKING, Any, List, Callable, Tuple, Union
+from typing import Optional, TYPE_CHECKING, Any, List, Callable, Tuple
 
 import jinja2
 
@@ -63,7 +63,7 @@ recipe_time_ranges = {
 class FactorioModFile(worlds.Files.APContainer):
     game = "Factorio"
     compression_method = zipfile.ZIP_DEFLATED  # Factorio can't load LZMA archives
-    writing_tasks: List[Callable[[], Tuple[str, Union[str, bytes]]]]
+    writing_tasks: List[Callable[[], Tuple[str, str]]]
 
     def __init__(self, *args: Any, **kwargs: Any):
         super().__init__(*args, **kwargs)
@@ -164,7 +164,9 @@ def generate_mod(world: "Factorio", output_directory: str):
     template_data["free_sample_blacklist"].update({item: 1 for item in multiworld.free_sample_blacklist[player].value})
     template_data["free_sample_blacklist"].update({item: 0 for item in multiworld.free_sample_whitelist[player].value})
 
-    zf_path = os.path.join(output_directory, versioned_mod_name + ".zip")
+    mod_dir = os.path.join(output_directory, versioned_mod_name)
+
+    zf_path = os.path.join(mod_dir + ".zip")
     mod = FactorioModFile(zf_path, player=player, player_name=multiworld.player_name[player])
 
     if world.zip_path:
@@ -175,13 +177,7 @@ def generate_mod(world: "Factorio", output_directory: str):
                     mod.writing_tasks.append(lambda arcpath=versioned_mod_name+"/"+path_part, content=zf.read(file):
                                              (arcpath, content))
     else:
-        basepath = os.path.join(os.path.dirname(__file__), "data", "mod")
-        for dirpath, dirnames, filenames in os.walk(basepath):
-            base_arc_path = (versioned_mod_name+"/"+os.path.relpath(dirpath, basepath)).rstrip("/.\\")
-            for filename in filenames:
-                mod.writing_tasks.append(lambda arcpath=base_arc_path+"/"+filename,
-                                                file_path=os.path.join(dirpath, filename):
-                                         (arcpath, open(file_path, "rb").read()))
+        shutil.copytree(os.path.join(os.path.dirname(__file__), "data", "mod"), mod_dir, dirs_exist_ok=True)
 
     mod.writing_tasks.append(lambda: (versioned_mod_name + "/data.lua",
                                       data_template.render(**template_data)))
@@ -201,3 +197,5 @@ def generate_mod(world: "Factorio", output_directory: str):
 
     # write the mod file
     mod.write()
+    # clean up
+    shutil.rmtree(mod_dir)

worlds/factorio/Options.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 import typing
 import datetime
 
-from Options import Choice, OptionDict, OptionSet, Option, DefaultOnToggle, Range, DeathLink, Toggle, \
-    StartInventoryPool
+from Options import Choice, OptionDict, OptionSet, ItemDict, Option, DefaultOnToggle, Range, DeathLink, AllowCollect, \
+    Toggle, StartInventoryPool
 from schema import Schema, Optional, And, Or
 
 # schema helpers
@@ -207,10 +207,11 @@ class RecipeIngredientsOffset(Range):
     range_end = 5
 
 
-class FactorioStartItems(OptionDict):
+class FactorioStartItems(ItemDict):
     """Mapping of Factorio internal item-name to amount granted on start."""
     display_name = "Starting Items"
-    default = {"burner-mining-drill": 4, "stone-furnace": 4,  "raw-fish": 50}
+    verify_item_name = False
+    default = {"burner-mining-drill": 19, "stone-furnace": 19}
 
 
 class FactorioFreeSampleBlacklist(OptionSet):
@@ -453,6 +454,7 @@ factorio_options: typing.Dict[str, type(Option)] = {
     "evolution_traps": EvolutionTrapCount,
     "evolution_trap_increase": EvolutionTrapIncrease,
     "death_link": DeathLink,
+    "allow_collect": AllowCollect,
     "energy_link": EnergyLink,
     "start_inventory_from_pool": StartInventoryPool,
 }

worlds/factorio/__init__.py

@@ -246,8 +246,7 @@ class Factorio(World):
                 location.access_rule = lambda state, ingredient=ingredient, custom_recipe=custom_recipe: \
                     (ingredient not in technology_table or state.has(ingredient, player)) and \
                     all(state.has(technology.name, player) for sub_ingredient in custom_recipe.ingredients
-                        for technology in required_technologies[sub_ingredient]) and \
-                    all(state.has(technology.name, player) for technology in required_technologies[custom_recipe.crafting_machine])
+                        for technology in required_technologies[sub_ingredient])
             else:
                 location.access_rule = lambda state, ingredient=ingredient: \
                     all(state.has(technology.name, player) for technology in required_technologies[ingredient])

worlds/factorio/data/mod_template/control.lua

@@ -11,6 +11,7 @@ TRAP_EVO_FACTOR = {{ evolution_trap_increase }} / 100
 MAX_SCIENCE_PACK = {{ max_science_pack }}
 GOAL = {{ goal }}
 ARCHIPELAGO_DEATH_LINK_SETTING = "archipelago-death-link-{{ slot_player }}-{{ seed_name }}"
+ARCHIPELAGO_ALLOW_COLLECT_SETTING = "archipelago-allow-collect-{{ slot_player }}-{{ seed_name }}"
 ENERGY_INCREMENT = {{ energy_link * 10000000 }}
 ENERGY_LINK_EFFICIENCY = 0.75
 
@@ -20,6 +21,12 @@ else
     DEATH_LINK = 0
 end
 
+if settings.global[ARCHIPELAGO_ALLOW_COLLECT_SETTING].value then
+    ALLOW_COLLECT = 1
+else
+    ALLOW_COLLECT = 0
+end
+
 CURRENTLY_DEATH_LOCK = 0
 
 {% if chunk_shuffle %}
@@ -257,6 +264,26 @@ function on_runtime_mod_setting_changed(event)
             dumpInfo(force)
         end
     end
+    if event.setting == ARCHIPELAGO_ALLOW_COLLECT_SETTING then
+        local force = game.forces["player"]
+        if global.received_tech == nil then
+            global.received_tech = {}
+        end
+        if settings.global[ARCHIPELAGO_ALLOW_COLLECT_SETTING].value then
+            ALLOW_COLLECT = 1
+            for item_name, _ in pairs(global.received_tech) do
+                tech = force.technologies[item_name]
+                if tech ~= nil and tech.researched ~= true then
+                    game.print({"", "Received [technology=" .. tech.name .. "] as it is already checked."})
+                    game.play_sound({path="utility/research_completed"})
+                    tech.researched = true
+                end
+            end
+            global.received_tech = {}
+        else
+            ALLOW_COLLECT = 0
+        end
+    end
 end
 script.on_event(defines.events.on_runtime_mod_setting_changed, on_runtime_mod_setting_changed)
 
@@ -658,18 +685,29 @@ commands.add_command("ap-get-technology", "Grant a technology, used by the Archi
     if global.index_sync == nil then
         global.index_sync = {}
     end
+    if global.received_tech == nil then
+        global.received_tech = {}
+    end
     local tech
     local force = game.forces["player"]
     chunks = split(call.parameter, "\t")
     local item_name = chunks[1]
-    local index = chunks[2]
+    local index = tonumber(chunks[2]) or chunks[2]
     local source = chunks[3] or "Archipelago"
     if index == -1 then -- for coop sync and restoring from an older savegame
         tech = force.technologies[item_name]
+        if tech == nil then
+            game.print("Unknown Item " .. item_name)
+            return
+        end
         if tech.researched ~= true then
-            game.print({"", "Received [technology=" .. tech.name .. "] as it is already checked."})
-            game.play_sound({path="utility/research_completed"})
-            tech.researched = true
+            if ALLOW_COLLECT == 1 then
+                game.print({"", "Received [technology=" .. tech.name .. "] as it is already checked."})
+                game.play_sound({path="utility/research_completed"})
+                tech.researched = true
+            else
+                global.received_tech[item_name] = 1
+            end
         end
         return
     elseif progressive_technologies[item_name] ~= nil then

worlds/factorio/data/mod_template/locale/en/locale.cfg

@@ -26,6 +26,8 @@ ap-{{ location.address }}-=Researching this technology sends something to someon
 
 [mod-setting-name]
 archipelago-death-link-{{ slot_player }}-{{ seed_name }}=Death Link
+archipelago-allow-collect-{{ slot_player }}-{{ seed_name }}=Allow Collect
 
 [mod-setting-description]
-archipelago-death-link-{{ slot_player }}-{{ seed_name }}=Kill other players in the same Archipelago Multiworld that also have Death Link turned on, when you die.
+archipelago-death-link-{{ slot_player }}-{{ seed_name }}=Kill other players in the same Archipelago Multiworld that also have Death Link turned on, when you die.
+archipelago-allow-collect-{{ slot_player }}-{{ seed_name }}=Allows released/collected tech locations to be marked as researched automatically.

worlds/factorio/data/mod_template/settings.lua

@@ -26,5 +26,15 @@ data:extend({
         {% else %}
             default_value = false
         {% endif %}
+    },
+    {
+        type = "bool-setting",
+        name = "archipelago-allow-collect-{{ slot_player }}-{{ seed_name }}",
+        setting_type = "runtime-global",
+        {% if allow_collect %}
+            default_value = true
+        {% else %}
+            default_value = false
+        {% endif %}
     }
 })

worlds/ff1/__init__.py

@@ -74,7 +74,6 @@ class FF1World(World):
         items = get_options(self.multiworld, 'items', self.player)
         goal_rule = generate_rule([[name for name in items.keys() if name in FF1_PROGRESSION_LIST and name != "Shard"]],
                                   self.player)
-        terminated_event.access_rule = goal_rule
         if "Shard" in items.keys():
             def goal_rule_and_shards(state):
                 return goal_rule(state) and state.has("Shard", self.player, 32)

worlds/ffmq/Client.py

@@ -71,7 +71,7 @@ class FFMQClient(SNIClient):
         received = await snes_read(ctx, RECEIVED_DATA[0], RECEIVED_DATA[1])
         data = await snes_read(ctx, READ_DATA_START, READ_DATA_END - READ_DATA_START)
         check_2 = await snes_read(ctx, 0xF53749, 1)
-        if check_1 in (b'\x00', b'\x55') or check_2 in (b'\x00', b'\x55'):
+        if check_1 == b'\x00' or check_2 == b'\x00':
             return
 
         def get_range(data_range):

worlds/ffmq/Items.py

@@ -187,7 +187,6 @@ item_table = {
     "Pazuzu 5F": ItemData(None, ItemClassification.progression),
     "Pazuzu 6F": ItemData(None, ItemClassification.progression),
     "Dark King": ItemData(None, ItemClassification.progression),
-    "Tristam Bone Item Given": ItemData(None, ItemClassification.progression),
     #"Barred": ItemData(None, ItemClassification.progression),
 
 }
@@ -223,6 +222,11 @@ for item, data in item_table.items():
 def create_items(self) -> None:
     items = []
     starting_weapon = self.multiworld.starting_weapon[self.player].current_key.title().replace("_", " ")
+    if self.multiworld.progressive_gear[self.player]:
+        for item_group in prog_map:
+            if starting_weapon in self.item_name_groups[item_group]:
+                starting_weapon = prog_map[item_group]
+                break
     self.multiworld.push_precollected(self.create_item(starting_weapon))
     self.multiworld.push_precollected(self.create_item("Steel Armor"))
     if self.multiworld.sky_coin_mode[self.player] == "start_with":

worlds/ffmq/Options.py

@@ -1,4 +1,4 @@
-from Options import Choice, FreeText, Toggle, Range
+from Options import Choice, FreeText, Toggle
 
 
 class Logic(Choice):
@@ -131,21 +131,6 @@ class EnemizerAttacks(Choice):
     default = 0
 
 
-class EnemizerGroups(Choice):
-    """Set which enemy groups will be affected by Enemizer."""
-    display_name = "Enemizer Groups"
-    option_mobs_only = 0
-    option_mobs_and_bosses = 1
-    option_mobs_bosses_and_dark_king = 2
-    default = 1
-
-
-class ShuffleResWeakType(Toggle):
-    """Resistance and Weakness types are shuffled for all enemies."""
-    display_name = "Shuffle Resistance/Weakness Types"
-    default = 0
-
-
 class ShuffleEnemiesPositions(Toggle):
     """Instead of their original position in a given map, enemies are randomly placed."""
     display_name = "Shuffle Enemies' Positions"
@@ -246,81 +231,6 @@ class BattlefieldsBattlesQuantities(Choice):
     option_random_one_through_ten = 6
 
 
-class CompanionLevelingType(Choice):
-    """Set how companions gain levels.
-    Quests: Complete each companion's individual quest for them to promote to their second version.
-    Quests Extended: Each companion has four exclusive quests, leveling each time a quest is completed.
-    Save the Crystals (All): Each time a Crystal is saved, all companions gain levels.
-    Save the Crystals (Individual): Each companion will level to their second version when a specific Crystal is saved.
-    Benjamin Level: Companions' level tracks Benjamin's."""
-    option_quests = 0
-    option_quests_extended = 1
-    option_save_crystals_individual = 2
-    option_save_crystals_all = 3
-    option_benjamin_level = 4
-    option_benjamin_level_plus_5 = 5
-    option_benjamin_level_plus_10 = 6
-    default = 0
-    display_name = "Companion Leveling Type"
-
-
-class CompanionSpellbookType(Choice):
-    """Update companions' spellbook.
-    Standard: Original game spellbooks.
-    Extended: Add some extra spells. Tristam gains Exit and Quake and Reuben gets Blizzard.
-    Random Balanced: Randomize the spellbooks with an appropriate mix of spells.
-    Random Chaos: Randomize the spellbooks in total free-for-all."""
-    option_standard = 0
-    option_extended = 1
-    option_random_balanced = 2
-    option_random_chaos = 3
-    default = 0
-    display_name = "Companion Spellbook Type"
-
-
-class StartingCompanion(Choice):
-    """Set a companion to start with.
-    Random Companion: Randomly select one companion.
-    Random Plus None: Randomly select a companion, with the possibility of none selected."""
-    display_name = "Starting Companion"
-    default = 0
-    option_none = 0
-    option_kaeli = 1
-    option_tristam = 2
-    option_phoebe = 3
-    option_reuben = 4
-    option_random_companion = 5
-    option_random_plus_none = 6
-
-
-class AvailableCompanions(Range):
-    """Select randomly which companions will join your party. Unavailable companions can still be reached to get their items and complete their quests if needed.
-    Note: If a Starting Companion is selected, it will always be available, regardless of this setting."""
-    display_name = "Available Companions"
-    default = 4
-    range_start = 0
-    range_end = 4
-
-
-class CompanionsLocations(Choice):
-    """Set the primary location of companions. Their secondary location is always the same.
-    Standard: Companions will be at the same locations as in the original game.
-    Shuffled: Companions' locations are shuffled amongst themselves.
-    Shuffled Extended: Add all the Temples, as well as Phoebe's House and the Rope Bridge as possible locations."""
-    display_name = "Companions' Locations"
-    default = 0
-    option_standard = 0
-    option_shuffled = 1
-    option_shuffled_extended = 2
-
-
-class KaelisMomFightsMinotaur(Toggle):
-    """Transfer Kaeli's requirements (Tree Wither, Elixir) and the two items she's giving to her mom.
-    Kaeli will be available to join the party right away without the Tree Wither."""
-    display_name = "Kaeli's Mom Fights Minotaur"
-    default = 0
-
-
 option_definitions = {
     "logic": Logic,
     "brown_boxes": BrownBoxes,
@@ -328,21 +238,12 @@ option_definitions = {
     "shattered_sky_coin_quantity": ShatteredSkyCoinQuantity,
     "starting_weapon": StartingWeapon,
     "progressive_gear": ProgressiveGear,
-    "leveling_curve": LevelingCurve,
-    "starting_companion": StartingCompanion,
-    "available_companions": AvailableCompanions,
-    "companions_locations": CompanionsLocations,
-    "kaelis_mom_fight_minotaur": KaelisMomFightsMinotaur,
-    "companion_leveling_type": CompanionLevelingType,
-    "companion_spellbook_type": CompanionSpellbookType,
     "enemies_density": EnemiesDensity,
     "enemies_scaling_lower": EnemiesScalingLower,
     "enemies_scaling_upper": EnemiesScalingUpper,
     "bosses_scaling_lower": BossesScalingLower,
     "bosses_scaling_upper": BossesScalingUpper,
     "enemizer_attacks": EnemizerAttacks,
-    "enemizer_groups": EnemizerGroups,
-    "shuffle_res_weak_types": ShuffleResWeakType,
     "shuffle_enemies_position": ShuffleEnemiesPositions,
     "progressive_formations": ProgressiveFormations,
     "doom_castle_mode": DoomCastle,
@@ -352,5 +253,6 @@ option_definitions = {
     "crest_shuffle": CrestShuffle,
     "shuffle_battlefield_rewards": ShuffleBattlefieldRewards,
     "map_shuffle_seed": MapShuffleSeed,
+    "leveling_curve": LevelingCurve,
     "battlefields_battles_quantities": BattlefieldsBattlesQuantities,
 }

worlds/ffmq/Output.py

@@ -35,58 +35,46 @@ def generate_output(self, output_directory):
                                    "item_name": location.item.name})
 
     def cc(option):
-        return option.current_key.title().replace("_", "").replace("OverworldAndDungeons",
-            "OverworldDungeons").replace("MobsAndBosses", "MobsBosses").replace("MobsBossesAndDarkKing",
-            "MobsBossesDK").replace("BenjaminLevelPlus", "BenPlus").replace("BenjaminLevel", "BenPlus0").replace(
-            "RandomCompanion", "Random")
+        return option.current_key.title().replace("_", "").replace("OverworldAndDungeons", "OverworldDungeons")
 
     def tf(option):
         return True if option else False
 
     options = deepcopy(settings_template)
     options["name"] = self.multiworld.player_name[self.player]
-    option_writes = {
-        "enemies_density": cc(self.multiworld.enemies_density[self.player]),
-        "chests_shuffle": "Include",
-        "shuffle_boxes_content": self.multiworld.brown_boxes[self.player] == "shuffle",
-        "npcs_shuffle": "Include",
-        "battlefields_shuffle": "Include",
-        "logic_options": cc(self.multiworld.logic[self.player]),
-        "shuffle_enemies_position": tf(self.multiworld.shuffle_enemies_position[self.player]),
-        "enemies_scaling_lower": cc(self.multiworld.enemies_scaling_lower[self.player]),
-        "enemies_scaling_upper": cc(self.multiworld.enemies_scaling_upper[self.player]),
-        "bosses_scaling_lower": cc(self.multiworld.bosses_scaling_lower[self.player]),
-        "bosses_scaling_upper": cc(self.multiworld.bosses_scaling_upper[self.player]),
-        "enemizer_attacks": cc(self.multiworld.enemizer_attacks[self.player]),
-        "leveling_curve": cc(self.multiworld.leveling_curve[self.player]),
-        "battles_quantity": cc(self.multiworld.battlefields_battles_quantities[self.player]) if
-                               self.multiworld.battlefields_battles_quantities[self.player].value < 5 else
-                               "RandomLow" if
-                               self.multiworld.battlefields_battles_quantities[self.player].value == 5 else
-                               "RandomHigh",
-        "shuffle_battlefield_rewards": tf(self.multiworld.shuffle_battlefield_rewards[self.player]),
-        "random_starting_weapon": True,
-        "progressive_gear": tf(self.multiworld.progressive_gear[self.player]),
-        "tweaked_dungeons": tf(self.multiworld.tweak_frustrating_dungeons[self.player]),
-        "doom_castle_mode": cc(self.multiworld.doom_castle_mode[self.player]),
-        "doom_castle_shortcut": tf(self.multiworld.doom_castle_shortcut[self.player]),
-        "sky_coin_mode": cc(self.multiworld.sky_coin_mode[self.player]),
-        "sky_coin_fragments_qty": cc(self.multiworld.shattered_sky_coin_quantity[self.player]),
-        "enable_spoilers": False,
-        "progressive_formations": cc(self.multiworld.progressive_formations[self.player]),
-        "map_shuffling": cc(self.multiworld.map_shuffle[self.player]),
-        "crest_shuffle": tf(self.multiworld.crest_shuffle[self.player]),
-        "enemizer_groups": cc(self.multiworld.enemizer_groups[self.player]),
-        "shuffle_res_weak_type": tf(self.multiworld.shuffle_res_weak_types[self.player]),
-        "companion_leveling_type": cc(self.multiworld.companion_leveling_type[self.player]),
-        "companion_spellbook_type": cc(self.multiworld.companion_spellbook_type[self.player]),
-        "starting_companion": cc(self.multiworld.starting_companion[self.player]),
-        "available_companions": ["Zero", "One", "Two",
-                                 "Three", "Four"][self.multiworld.available_companions[self.player].value],
-        "companions_locations": cc(self.multiworld.companions_locations[self.player]),
-        "kaelis_mom_fight_minotaur": tf(self.multiworld.kaelis_mom_fight_minotaur[self.player]),
-    }
 
+    option_writes = {
+                   "enemies_density": cc(self.multiworld.enemies_density[self.player]),
+                   "chests_shuffle": "Include",
+                   "shuffle_boxes_content": self.multiworld.brown_boxes[self.player] == "shuffle",
+                   "npcs_shuffle": "Include",
+                   "battlefields_shuffle": "Include",
+                   "logic_options": cc(self.multiworld.logic[self.player]),
+                   "shuffle_enemies_position": tf(self.multiworld.shuffle_enemies_position[self.player]),
+                   "enemies_scaling_lower": cc(self.multiworld.enemies_scaling_lower[self.player]),
+                   "enemies_scaling_upper": cc(self.multiworld.enemies_scaling_upper[self.player]),
+                   "bosses_scaling_lower": cc(self.multiworld.bosses_scaling_lower[self.player]),
+                   "bosses_scaling_upper": cc(self.multiworld.bosses_scaling_upper[self.player]),
+                   "enemizer_attacks": cc(self.multiworld.enemizer_attacks[self.player]),
+                   "leveling_curve": cc(self.multiworld.leveling_curve[self.player]),
+                   "battles_quantity": cc(self.multiworld.battlefields_battles_quantities[self.player]) if
+                                          self.multiworld.battlefields_battles_quantities[self.player].value < 5 else
+                                         "RandomLow" if
+                                         self.multiworld.battlefields_battles_quantities[self.player].value == 5 else
+                                         "RandomHigh",
+                   "shuffle_battlefield_rewards": tf(self.multiworld.shuffle_battlefield_rewards[self.player]),
+                   "random_starting_weapon": True,
+                   "progressive_gear": tf(self.multiworld.progressive_gear[self.player]),
+                   "tweaked_dungeons": tf(self.multiworld.tweak_frustrating_dungeons[self.player]),
+                   "doom_castle_mode": cc(self.multiworld.doom_castle_mode[self.player]),
+                   "doom_castle_shortcut": tf(self.multiworld.doom_castle_shortcut[self.player]),
+                   "sky_coin_mode": cc(self.multiworld.sky_coin_mode[self.player]),
+                   "sky_coin_fragments_qty": cc(self.multiworld.shattered_sky_coin_quantity[self.player]),
+                   "enable_spoilers": False,
+                   "progressive_formations": cc(self.multiworld.progressive_formations[self.player]),
+                   "map_shuffling": cc(self.multiworld.map_shuffle[self.player]),
+                   "crest_shuffle": tf(self.multiworld.crest_shuffle[self.player]),
+               }
     for option, data in option_writes.items():
         options["Final Fantasy Mystic Quest"][option][data] = 1
 
@@ -95,7 +83,7 @@ def generate_output(self, output_directory):
                               'utf8')
     self.rom_name_available_event.set()
 
-    setup = {"version": "1.5", "name": self.multiworld.player_name[self.player], "romname": rom_name, "seed":
+    setup = {"version": "1.4", "name": self.multiworld.player_name[self.player], "romname": rom_name, "seed":
              hex(self.multiworld.per_slot_randoms[self.player].randint(0, 0xFFFFFFFF)).split("0x")[1].upper()}
 
     starting_items = [output_item_name(item) for item in self.multiworld.precollected_items[self.player]]

worlds/ffmq/Regions.py

@@ -67,10 +67,10 @@ def create_regions(self):
         self.multiworld.regions.append(create_region(self.multiworld, self.player, room["name"], room["id"],
             [FFMQLocation(self.player, object["name"], location_table[object["name"]] if object["name"] in
             location_table else None, object["type"], object["access"],
-            self.create_item(yaml_item(object["on_trigger"][0])) if object["type"] == "Trigger" else None) for object in
-            room["game_objects"] if "Hero Chest" not in object["name"] and object["type"] not in ("BattlefieldGp",
-            "BattlefieldXp") and (object["type"] != "Box" or self.multiworld.brown_boxes[self.player] == "include") and
-            not (object["name"] == "Kaeli Companion" and not object["on_trigger"])], room["links"]))
+            self.create_item(yaml_item(object["on_trigger"][0])) if object["type"] == "Trigger" else None) for
+            object in room["game_objects"] if "Hero Chest" not in object["name"] and object["type"] not in
+            ("BattlefieldGp", "BattlefieldXp") and (object["type"] != "Box" or
+            self.multiworld.brown_boxes[self.player] == "include")], room["links"]))
 
     dark_king_room = self.multiworld.get_region("Doom Castle Dark King Room", self.player)
     dark_king = FFMQLocation(self.player, "Dark King", None, "Trigger", [])

worlds/ffmq/__init__.py

@@ -108,10 +108,8 @@ class FFMQWorld(World):
                 map_shuffle = multiworld.map_shuffle[world.player].value
                 crest_shuffle = multiworld.crest_shuffle[world.player].current_key
                 battlefield_shuffle = multiworld.shuffle_battlefield_rewards[world.player].current_key
-                companion_shuffle = multiworld.companions_locations[world.player].value
-                kaeli_mom = multiworld.kaelis_mom_fight_minotaur[world.player].current_key
 
-                query = f"s={seed}&m={map_shuffle}&c={crest_shuffle}&b={battlefield_shuffle}&cs={companion_shuffle}&km={kaeli_mom}"
+                query = f"s={seed}&m={map_shuffle}&c={crest_shuffle}&b={battlefield_shuffle}"
 
                 if query in rooms_data:
                     world.rooms = rooms_data[query]

worlds/ffmq/data/entrances.yaml

@@ -827,12 +827,12 @@
   id: 164
   area: 47
   coordinates: [14, 6]
-  teleporter: [98, 8] # Script for reuben, original value [16, 2]
+  teleporter: [16, 2]
 - name: Fireburg - Hotel
   id: 165
   area: 47
   coordinates: [20, 8]
-  teleporter: [96, 8] # It's a script now for tristam, original value [17, 2]
+  teleporter: [17, 2]
 - name: Fireburg - GrenadeMan House Script
   id: 166
   area: 47
@@ -1178,16 +1178,6 @@
   area: 60
   coordinates: [2, 7]
   teleporter: [123, 0]
-- name: Lava Dome Pointless Room - Visit Quest Script 1
-  id: 490
-  area: 60
-  coordinates: [4, 4]
-  teleporter: [99, 8]
-- name: Lava Dome Pointless Room - Visit Quest Script 2
-  id: 491
-  area: 60
-  coordinates: [4, 5]
-  teleporter: [99, 8]
 - name: Lava Dome Lower Moon Helm Room - Left Entrance
   id: 235
   area: 60
@@ -1578,11 +1568,6 @@
   area: 79
   coordinates: [2, 45]
   teleporter: [174, 0]
-- name: Mount Gale - Visit Quest
-  id: 494
-  area: 79
-  coordinates: [44, 7]
-  teleporter: [101, 8]
 - name: Windia - Main Entrance 1
   id: 312
   area: 80
@@ -1628,11 +1613,11 @@
   area: 80
   coordinates: [21, 39]
   teleporter: [30, 5]
-- name: Windia - INN's Script # Change to teleporter /  Change back to script!
+- name: Windia - INN's Script # Change to teleporter
   id: 321
   area: 80
   coordinates: [18, 34]
-  teleporter: [97, 8] # Original value [79, 8] > [31, 2]
+  teleporter: [31, 2] # Original value [79, 8]
 - name: Windia - Vendor House
   id: 322
   area: 80
@@ -1712,7 +1697,7 @@
   id: 337
   area: 82
   coordinates: [45, 24]
-  teleporter: [102, 8]          # Changed to script, original value [215, 0]
+  teleporter: [215, 0]
 - name: Windia Inn Lobby - Exit
   id: 338
   area: 82
@@ -2013,16 +1998,6 @@
   area: 95
   coordinates: [29, 37]
   teleporter: [70, 8]
-- name: Light Temple - Visit Quest Script 1
-  id: 492
-  area: 95
-  coordinates: [34, 39]
-  teleporter: [100, 8]
-- name: Light Temple - Visit Quest Script 2
-  id: 493
-  area: 95
-  coordinates: [35, 39]
-  teleporter: [100, 8]
 - name: Ship Dock - Mobius Teleporter Script
   id: 397
   area: 96

worlds/ffmq/data/rooms.yaml

@@ -309,13 +309,13 @@
     location: "WindiaBattlefield01"
     location_slot: "WindiaBattlefield01"
     type: "BattlefieldXp"
-    access: ["SandCoin", "RiverCoin"]
+    access: []
   - name: "South of Windia Battlefield"
     object_id: 0x14
     location: "WindiaBattlefield02"
     location_slot: "WindiaBattlefield02"
     type: "BattlefieldXp"
-    access: ["SandCoin", "RiverCoin"]
+    access: []
   links:
   - target_room: 9   # Focus Tower Windia
     location: "FocusTowerWindia"
@@ -739,7 +739,7 @@
     object_id: 0x2E
     type: "Box"
     access: []
-  - name: "Kaeli Companion"
+  - name: "Kaeli 1"
     object_id: 0
     type: "Trigger"
     on_trigger: ["Kaeli1"]
@@ -838,7 +838,7 @@
 - name: Sand Temple
   id: 24
   game_objects:
-  - name: "Tristam Companion"
+  - name: "Tristam Sand Temple"
     object_id: 0
     type: "Trigger"
     on_trigger: ["Tristam"]
@@ -883,11 +883,6 @@
     object_id: 2
     type: "NPC"
     access: ["Tristam"]
-  - name: "Tristam Bone Dungeon Item Given"
-    object_id: 0
-    type: "Trigger"
-    on_trigger: ["TristamBoneItemGiven"]
-    access: ["Tristam"]
   links:
   - target_room: 25
     entrance: 59
@@ -1085,7 +1080,7 @@
     object_id: 0x40
     type: "Box"
     access: []
-  - name: "Phoebe Companion"
+  - name: "Phoebe"
     object_id: 0
     type: "Trigger"
     on_trigger: ["Phoebe1"]
@@ -1851,11 +1846,11 @@
     access: []
   - target_room: 77
     entrance: 164
-    teleporter: [98, 8] # original value [16, 2]
+    teleporter: [16, 2]
     access: []
   - target_room: 82
     entrance: 165
-    teleporter: [96, 8] # original value [17, 2]
+    teleporter: [17, 2]
     access: []
   - target_room: 208
     access: ["Claw"]
@@ -1880,7 +1875,7 @@
     object_id: 14
     type: "NPC"
     access: ["ReubenDadSaved"]
-  - name: "Reuben Companion"
+  - name: "Reuben"
     object_id: 0
     type: "Trigger"
     on_trigger: ["Reuben1"]
@@ -1956,7 +1951,12 @@
   - name: "Fireburg - Tristam"
     object_id: 10
     type: "NPC"
-    access: ["Tristam", "TristamBoneItemGiven"]
+    access: []
+  - name: "Tristam Fireburg"
+    object_id: 0
+    type: "Trigger"
+    on_trigger: ["Tristam"]
+    access: []
   links:
   - target_room: 76
     entrance: 177
@@ -3183,7 +3183,7 @@
     access: []
   - target_room: 163
     entrance: 321
-    teleporter: [97, 8]
+    teleporter: [31, 2]
     access: []
   - target_room: 165
     entrance: 322
@@ -3292,7 +3292,7 @@
     access: []
   - target_room: 164
     entrance: 337
-    teleporter: [102, 8]
+    teleporter: [215, 0]
     access: []
 - name: Windia Inn Beds
   id: 164

worlds/ffmq/data/settings.yaml

@@ -73,57 +73,14 @@ Final Fantasy Mystic Quest:
     Chaos: 0
     SelfDestruct: 0
     SimpleShuffle: 0
-  enemizer_groups:
-    MobsOnly: 0
-    MobsBosses: 0
-    MobsBossesDK: 0
-  shuffle_res_weak_type:
-    true: 0
-    false: 0
   leveling_curve:
     Half: 0
     Normal: 0
     OneAndHalf: 0
     Double: 0
-    DoubleAndHalf: 0
+    DoubleHalf: 0
     Triple: 0
     Quadruple: 0
-  companion_leveling_type:
-    Quests: 0
-    QuestsExtended: 0
-    SaveCrystalsIndividual: 0
-    SaveCrystalsAll: 0
-    BenPlus0: 0
-    BenPlus5: 0
-    BenPlus10: 0
-  companion_spellbook_type:
-    Standard: 0
-    Extended: 0
-    RandomBalanced: 0
-    RandomChaos: 0
-  starting_companion:
-    None: 0
-    Kaeli: 0
-    Tristam: 0
-    Phoebe: 0
-    Reuben: 0
-    Random: 0
-    RandomPlusNone: 0
-  available_companions:
-    Zero: 0
-    One: 0
-    Two: 0
-    Three: 0
-    Four: 0
-    Random14: 0
-    Random04: 0
-  companions_locations:
-    Standard: 0
-    Shuffled: 0
-    ShuffledExtended: 0
-  kaelis_mom_fight_minotaur:
-    true: 0
-    false: 0
   battles_quantity:
     Ten: 0
     Seven: 0

worlds/ffmq/docs/setup_en.md

@@ -2,7 +2,7 @@
 
 ## Required Software
 
-- [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases).
+- [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases). Make sure to check the box for `SNI Client`
 
 - Hardware or software capable of loading and playing SNES ROM files
     - An emulator capable of connecting to SNI such as:
@@ -19,8 +19,8 @@ The Archipelago community cannot supply you with this.
 
 ### Windows Setup
 
-1. Download and install [Archipelago](<https://github.com/ArchipelagoMW/Archipelago/releases/latest>). **The installer 
-   file is located in the assets section at the bottom of the version information.**
+1. During the installation of Archipelago, you will have been asked to install the SNI Client. If you did not do this,
+   or you are on an older version, you may run the installer again to install the SNI Client.
 2. If you are using an emulator, you should assign your Lua capable emulator as your default program for launching ROM
    files.
     1. Extract your emulator's folder to your Desktop, or somewhere you will remember.

worlds/generic/Rules.py

@@ -1,5 +1,4 @@
 import collections
-import logging
 import typing
 
 from BaseClasses import LocationProgressType, MultiWorld, Location, Region, Entrance
@@ -82,18 +81,15 @@ def locality_rules(world: MultiWorld):
                     i.name not in sending_blockers[i.player] and old_rule(i)
 
 
-def exclusion_rules(multiworld: MultiWorld, player: int, exclude_locations: typing.Set[str]) -> None:
+def exclusion_rules(world: MultiWorld, player: int, exclude_locations: typing.Set[str]) -> None:
     for loc_name in exclude_locations:
         try:
-            location = multiworld.get_location(loc_name, player)
+            location = world.get_location(loc_name, player)
         except KeyError as e:  # failed to find the given location. Check if it's a legitimate location
-            if loc_name not in multiworld.worlds[player].location_name_to_id:
+            if loc_name not in world.worlds[player].location_name_to_id:
                 raise Exception(f"Unable to exclude location {loc_name} in player {player}'s world.") from e
         else:
-            if not location.event:
-                location.progress_type = LocationProgressType.EXCLUDED
-            else:
-                logging.warning(f"Unable to exclude location {loc_name} in player {player}'s world.")
+            location.progress_type = LocationProgressType.EXCLUDED
 
 
 def set_rule(spot: typing.Union["BaseClasses.Location", "BaseClasses.Entrance"], rule: CollectionRule):

worlds/generic/docs/setup_en.md

@@ -17,22 +17,19 @@ The most recent public release of Archipelago can be found on the GitHub Release
 Run the exe file, and after accepting the license agreement you will be asked which components you would like to
 install.
 
-Archipelago installations are automatically bundled with some programs. These include a launcher, a generator, a
-server and some clients.
+The generator allows you to generate multiworld games on your computer. The ROM setups are required if anyone in the
+game that you generate wants to play any of those games as they are needed to generate the relevant patch files. If you
+do not own the game, uncheck the relevant box. If you gain the game later, the installer can be run again to install and
+set up new components.
 
-- The launcher lets you quickly access Archipelago's different components and programs. It is found under the name 
-  `ArchipelagoLauncher` and can be found in the main directory of your Archipelago installation.
-
-- The generator allows you to generate multiworld games on your computer. Please refer to the 'Generating a game'
-  section of this guide for more information about it.
-
-- The server will allow you to host the multiworld on your machine. Hosting on your machine requires forwarding the port
+The server will allow you to host the multiworld on your machine. Hosting on your machine requires forwarding the port
 you are hosting on. The default port for Archipelago is `38281`. If you are unsure how to do this there are plenty of
 other guides on the internet that will be more suited to your hardware.
 
-- The clients are what are used to connect your game to the multiworld. Some games use a client that is automatically
-installed with an Archipelago installation. You can access those clients via the launcher or by navigating
-to your Archipelago installation. 
+The `Clients` are what are used to connect your game to the multiworld. If the game you plan to play is available
+here, go ahead and install its client as well. If the game you choose to play is supported by Archipelago but not listed
+in the installation, check the setup guide for that game. Installing a client for a ROM based game requires you to have
+a legally obtained ROM for that game as well.
 
 ## Generating a game
 
@@ -75,18 +72,14 @@ If you have downloaded the settings, or have created a settings file manually, t
 
 #### On your local installation
 
-To generate a game on your local machine, make sure to install the Archipelago software. Navigate to your Archipelago
+To generate a game on your local machine, make sure to install the Archipelago software, and ensure to select the
+`Generator` component, as well as the `ROM setup` for any games you will want to play. Navigate to your Archipelago
 installation (usually C:\ProgramData\Archipelago), and place the settings file you have either created or downloaded
 from the website in the `Players` folder.
 
-Run `ArchipelagoGenerate.exe`, or click on `Generate` in the launcher, and it will inform you whether the generation
-was successful or not. If successful, there will be an output zip in the `output` folder 
-(usually named something like `AP_XXXXX.zip`). This will contain all relevant information to the session, including the
-spoiler log, if one was generated.
-
-Please note that some games require you to own their ROM files to generate with them as they are needed to generate the
-relevant patch files. When you generate with a ROM game for the first time, you will be asked to locate its base ROM file.
-This step only needs to be done once.
+Run `ArchipelagoGenerate.exe`, and it will inform you whether the generation was successful or not. If successful, there
+will be an output zip in the `output` folder (usually named something like `AP_XXXXX.zip`). This will contain all
+relevant information to the session, including the spoiler log, if one was generated.
 
 ### Generating a multiplayer game
 
@@ -104,9 +97,12 @@ player name.
 
 #### On the website
 
-Gather all player YAML files into a single place, then navigate to the [Generate Page](/generate). Select the host settings
-you would like, click on `Upload File(s)`, and select all player YAML files. The site also accepts `zip` archives containing YAML
-files.
+Gather all player YAML files into a single place, and compress them into a zip file. This can be done by pressing
+ctrl/cmd + clicking on each file until all are selected, right-clicking one of the files, and clicking
+`compress to ZIP file` or `send to > compressed folder`.
+
+Navigate to the [Generate Page](/generate), select the host settings you would like, click on `Upload File`, and
+select the newly created zip from the opened window.
 
 After some time, you will be redirected to a seed info page that will display the generated seed, the time it was
 created, the number of players, the spoiler (if one was created) and all rooms created from this seed.
@@ -118,11 +114,8 @@ It is possible to generate the multiworld locally, using a local Archipelago ins
 Archipelago installation folder (usually C:\ProgramData\Archipelago) and placing each YAML file in the `Players` folder.
 If the folder does not exist then it must be created manually. The files here should not be compressed.
 
-After filling the `Players` folder, run`ArchipelagoGenerate.exe` or click `Generate` in the launcher. The output of 
-the generation is placed in the `output` folder (usually named something like `AP_XXXXX.zip`).
-
-Please note that if any player in the game you want to generate plays a game that needs a ROM file to generate, you will
-need the corresponding ROM files.
+After filling the `Players` folder, the `ArchipelagoGenerate.exe` program should be run in order to generate a
+multiworld. The output of this process is placed in the `output` folder (usually named something like `AP_XXXXX.zip`).
 
 ##### Changing local host settings for generation
 
@@ -130,12 +123,10 @@ Sometimes there are various settings that you may want to change before rolling
 auto-release, plando support, or setting a password.
 
 All of these settings, plus other options, may be changed by modifying the `host.yaml` file in the Archipelago
-installation folder. You can quickly access this file by clicking on `Open host.yaml` in the launcher. The settings
-chosen here are baked into the `.archipelago` file that gets output with the other files after generation, so if you 
-are rolling locally, ensure this file is edited to your liking **before** rolling the seed. This file is overwritten 
-when running the Archipelago Installation software. If you have changed settings in this file, and would like to retain 
-them, you may rename the file to `options.yaml`. 
-
+installation folder. The settings chosen here are baked into the `.archipelago` file that gets output with the other
+files after generation, so if you are rolling locally, ensure this file is edited to your liking **before** rolling the
+seed. This file is overwritten when running the Archipelago Installation software. If you have changed settings in this
+file, and would like to retain them, you may rename the file to `options.yaml`.
 
 ## Hosting an Archipelago Server
 

worlds/hk/Options.py

@@ -2,7 +2,7 @@ import typing
 from .ExtractedData import logic_options, starts, pool_options
 from .Rules import cost_terms
 
-from Options import Option, DefaultOnToggle, Toggle, Choice, Range, OptionDict, NamedRange, DeathLink
+from Options import Option, DefaultOnToggle, Toggle, Choice, Range, OptionDict, NamedRange
 from .Charms import vanilla_costs, names as charm_names
 
 if typing.TYPE_CHECKING:
@@ -402,34 +402,22 @@ class WhitePalace(Choice):
     default = 0
 
 
-class ExtraPlatforms(DefaultOnToggle):
-    """Places additional platforms to make traveling throughout Hallownest more convenient."""
-
-
-class DeathLinkShade(Choice):
-    """Sets whether to create a shade when you are killed by a DeathLink and how to handle your existing shade, if any.
-
-    vanilla: DeathLink deaths function like any other death and overrides your existing shade (including geo), if any.
-    shadeless: DeathLink deaths do not spawn shades. Your existing shade (including geo), if any, is untouched.
-    shade: DeathLink deaths spawn a shade if you do not have an existing shade. Otherwise, it acts like shadeless.
-
-    * This option has no effect if DeathLink is disabled.
-    ** Self-death shade behavior is not changed; if a self-death normally creates a shade in vanilla, it will override
-        your existing shade, if any.
+class DeathLink(Choice):
     """
-    option_vanilla = 0
+    When you die, everyone dies. Of course the reverse is true too.
+    When enabled, choose how incoming deathlinks are handled:
+    vanilla: DeathLink kills you and is just like any other death.  RIP your previous shade and geo.
+    shadeless: DeathLink kills you, but no shade spawns and no geo is lost.  Your previous shade, if any, is untouched.
+    shade: DeathLink functions like a normal death if you do not already have a shade, shadeless otherwise.
+    """
+    option_off = 0
+    alias_no = 0
+    alias_true = 1
+    alias_on = 1
+    alias_yes = 1
     option_shadeless = 1
-    option_shade = 2
-    default = 2
-
-
-class DeathLinkBreaksFragileCharms(Toggle):
-    """Sets if fragile charms break when you are killed by a DeathLink.
-
-    * This option has no effect if DeathLink is disabled.
-    ** Self-death fragile charm behavior is not changed; if a self-death normally breaks fragile charms in vanilla, it
-        will continue to do so.
-    """
+    option_vanilla = 2
+    option_shade = 3
 
 
 class StartingGeo(Range):
@@ -488,8 +476,7 @@ hollow_knight_options: typing.Dict[str, type(Option)] = {
     **{
         option.__name__: option
         for option in (
-            StartLocation, Goal, WhitePalace, ExtraPlatforms, StartingGeo,
-            DeathLink, DeathLinkShade, DeathLinkBreaksFragileCharms,
+            StartLocation, Goal, WhitePalace, StartingGeo, DeathLink,
             MinimumGeoPrice, MaximumGeoPrice,
             MinimumGrubPrice, MaximumGrubPrice,
             MinimumEssencePrice, MaximumEssencePrice,
@@ -501,7 +488,7 @@ hollow_knight_options: typing.Dict[str, type(Option)] = {
             LegEaterShopSlots, GrubfatherRewardSlots,
             SeerRewardSlots, ExtraShopSlots,
             SplitCrystalHeart, SplitMothwingCloak, SplitMantisClaw,
-            CostSanity, CostSanityHybridChance
+            CostSanity, CostSanityHybridChance,
         )
     },
     **cost_sanity_weights

worlds/hk/__init__.py

@@ -419,16 +419,17 @@ class HKWorld(World):
     def set_rules(self):
         world = self.multiworld
         player = self.player
-        goal = world.Goal[player]
-        if goal == Goal.option_hollowknight:
-            world.completion_condition[player] = lambda state: state._hk_can_beat_thk(player)
-        elif goal == Goal.option_siblings:
-            world.completion_condition[player] = lambda state: state._hk_siblings_ending(player)
-        elif goal == Goal.option_radiance:
-            world.completion_condition[player] = lambda state: state._hk_can_beat_radiance(player)
-        else:
-            # Any goal
-            world.completion_condition[player] = lambda state: state._hk_can_beat_thk(player) or state._hk_can_beat_radiance(player)
+        if world.logic[player] != 'nologic':
+            goal = world.Goal[player]
+            if goal == Goal.option_hollowknight:
+                world.completion_condition[player] = lambda state: state._hk_can_beat_thk(player)
+            elif goal == Goal.option_siblings:
+                world.completion_condition[player] = lambda state: state._hk_siblings_ending(player)
+            elif goal == Goal.option_radiance:
+                world.completion_condition[player] = lambda state: state._hk_can_beat_radiance(player)
+            else:
+                # Any goal
+                world.completion_condition[player] = lambda state: state._hk_can_beat_thk(player) or state._hk_can_beat_radiance(player)
 
         set_rules(self)
 

worlds/hylics2/Rules.py

@@ -444,8 +444,6 @@ def set_rules(hylics2world):
             lambda state: paddle(state, player))
         add_rule(world.get_location("Arcade 1: Alcove Medallion", player),
             lambda state: paddle(state, player))
-        add_rule(world.get_location("Arcade 1: Lava Medallion", player),
-            lambda state: paddle(state, player))
         add_rule(world.get_location("Foglast: Under Lair Medallion", player),
             lambda state: bridge_key(state, player))
         add_rule(world.get_location("Foglast: Mid-Air Medallion", player),

worlds/kh2/Client.py

@@ -29,7 +29,6 @@ class KH2Context(CommonContext):
         self.kh2_local_items = None
         self.growthlevel = None
         self.kh2connected = False
-        self.kh2_finished_game = False
         self.serverconneced = False
         self.item_name_to_data = {name: data for name, data, in item_dictionary_table.items()}
         self.location_name_to_data = {name: data for name, data, in all_locations.items()}
@@ -80,6 +79,11 @@ class KH2Context(CommonContext):
                 },
             },
         }
+        self.front_of_inventory = {
+            "Sora":   0x2546,
+            "Donald": 0x2658,
+            "Goofy":  0x276C,
+        }
         self.kh2seedname = None
         self.kh2slotdata = None
         self.itemamount = {}
@@ -164,14 +168,6 @@ class KH2Context(CommonContext):
         self.ability_code_list = None
         self.master_growth = {"High Jump", "Quick Run", "Dodge Roll", "Aerial Dodge", "Glide"}
 
-        self.base_hp = 20
-        self.base_mp = 100
-        self.base_drive = 5
-        self.base_accessory_slots = 1
-        self.base_armor_slots = 1
-        self.base_item_slots = 3
-        self.front_ability_slots = [0x2546, 0x2658, 0x276C, 0x2548, 0x254A, 0x254C, 0x265A, 0x265C, 0x265E, 0x276E, 0x2770, 0x2772]
-
     async def server_auth(self, password_requested: bool = False):
         if password_requested and not self.password:
             await super(KH2Context, self).server_auth(password_requested)
@@ -222,12 +218,6 @@ class KH2Context(CommonContext):
     def kh2_read_byte(self, address):
         return int.from_bytes(self.kh2.read_bytes(self.kh2.base_address + address, 1), "big")
 
-    def kh2_read_int(self, address):
-        return self.kh2.read_int(self.kh2.base_address + address)
-
-    def kh2_write_int(self, address, value):
-        self.kh2.write_int(self.kh2.base_address + address, value)
-
     def on_package(self, cmd: str, args: dict):
         if cmd in {"RoomInfo"}:
             self.kh2seedname = args['seed_name']
@@ -485,7 +475,7 @@ class KH2Context(CommonContext):
 
     async def give_item(self, item, location):
         try:
-            # todo: ripout all the itemtype stuff and just have one dictionary. the only thing that needs to be tracked from the server/local is abilites
+            # todo: ripout all the itemtype stuff and just have one dictionary. the only thing that needs to be tracked from the server/local is abilites 
             itemname = self.lookup_id_to_item[item]
             itemdata = self.item_name_to_data[itemname]
             # itemcode = self.kh2_item_name_to_id[itemname]
@@ -516,8 +506,6 @@ class KH2Context(CommonContext):
                             ability_slot = self.kh2_seed_save_cache["GoofyInvo"][1]
                             self.kh2_seed_save_cache["AmountInvo"]["Ability"][itemname].append(ability_slot)
                             self.kh2_seed_save_cache["GoofyInvo"][1] -= 2
-                        if ability_slot in self.front_ability_slots:
-                            self.front_ability_slots.remove(ability_slot)
 
                 elif len(self.kh2_seed_save_cache["AmountInvo"]["Ability"][itemname]) < \
                         self.AbilityQuantityDict[itemname]:
@@ -529,14 +517,11 @@ class KH2Context(CommonContext):
                         ability_slot = self.kh2_seed_save_cache["DonaldInvo"][0]
                         self.kh2_seed_save_cache["AmountInvo"]["Ability"][itemname].append(ability_slot)
                         self.kh2_seed_save_cache["DonaldInvo"][0] -= 2
-                    else:
+                    elif itemname in self.goofy_ability_set:
                         ability_slot = self.kh2_seed_save_cache["GoofyInvo"][0]
                         self.kh2_seed_save_cache["AmountInvo"]["Ability"][itemname].append(ability_slot)
                         self.kh2_seed_save_cache["GoofyInvo"][0] -= 2
 
-                    if ability_slot in self.front_ability_slots:
-                        self.front_ability_slots.remove(ability_slot)
-
             elif itemdata.memaddr in {0x36C4, 0x36C5, 0x36C6, 0x36C0, 0x36CA}:
                 # if memaddr is in a bitmask location in memory
                 if itemname not in self.kh2_seed_save_cache["AmountInvo"]["Bitmask"]:
@@ -629,7 +614,7 @@ class KH2Context(CommonContext):
             master_sell = master_equipment | master_staff | master_shield
 
             await asyncio.create_task(self.IsInShop(master_sell))
-            # print(self.kh2_seed_save_cache["AmountInvo"]["Ability"])
+
             for item_name in master_amount:
                 item_data = self.item_name_to_data[item_name]
                 amount_of_items = 0
@@ -687,10 +672,10 @@ class KH2Context(CommonContext):
                             self.kh2_write_short(self.Save + slot, item_data.memaddr)
             # removes the duped ability if client gave faster than the game.
 
-            for ability in self.front_ability_slots:
-                if self.kh2_read_short(self.Save + ability) != 0:
-                    print(f"removed {self.Save + ability} from {ability}")
-                    self.kh2_write_short(self.Save + ability, 0)
+            for charInvo in {"Sora", "Donald", "Goofy"}:
+                if self.kh2_read_short(self.Save + self.front_of_inventory[charInvo]) != 0:
+                    print(f"removed {self.Save + self.front_of_inventory[charInvo]} from {charInvo}")
+                    self.kh2_write_short(self.Save + self.front_of_inventory[charInvo], 0)
 
             # remove the dummy level 1 growths if they are in these invo slots.
             for inventorySlot in {0x25CE, 0x25D0, 0x25D2, 0x25D4, 0x25D6, 0x25D8}:
@@ -754,60 +739,15 @@ class KH2Context(CommonContext):
                     self.kh2_write_byte(self.Save + item_data.memaddr, amount_of_items)
 
             for item_name in master_stat:
+                item_data = self.item_name_to_data[item_name]
                 amount_of_items = 0
                 amount_of_items += self.kh2_seed_save_cache["AmountInvo"]["StatIncrease"][item_name]
-                if self.kh2_read_byte(self.Slot1 + 0x1B2) >= 5:
-                    if item_name == ItemName.MaxHPUp:
-                        if self.kh2_read_byte(self.Save + 0x2498) < 3:  # Non-Critical
-                            Bonus = 5
-                        else:  # Critical
-                            Bonus = 2
-                        if self.kh2_read_int(self.Slot1 + 0x004) != self.base_hp + (Bonus * amount_of_items):
-                            self.kh2_write_int(self.Slot1 + 0x004, self.base_hp + (Bonus * amount_of_items))
-
-                    elif item_name == ItemName.MaxMPUp:
-                        if self.kh2_read_byte(self.Save + 0x2498) < 3:  # Non-Critical
-                            Bonus = 10
-                        else:  # Critical
-                            Bonus = 5
-                        if self.kh2_read_int(self.Slot1 + 0x184) != self.base_mp + (Bonus * amount_of_items):
-                            self.kh2_write_int(self.Slot1 + 0x184, self.base_mp + (Bonus * amount_of_items))
-
-                    elif item_name == ItemName.DriveGaugeUp:
-                        current_max_drive = self.kh2_read_byte(self.Slot1 + 0x1B2)
-                        # change when max drive is changed from 6 to 4
-                        if current_max_drive < 9 and current_max_drive != self.base_drive + amount_of_items:
-                            self.kh2_write_byte(self.Slot1 + 0x1B2, self.base_drive + amount_of_items)
-
-                    elif item_name == ItemName.AccessorySlotUp:
-                        current_accessory = self.kh2_read_byte(self.Save + 0x2501)
-                        if current_accessory != self.base_accessory_slots + amount_of_items:
-                            if 4 > current_accessory < self.base_accessory_slots + amount_of_items:
-                                self.kh2_write_byte(self.Save + 0x2501, current_accessory + 1)
-                            elif self.base_accessory_slots + amount_of_items < 4:
-                                self.kh2_write_byte(self.Save + 0x2501, self.base_accessory_slots + amount_of_items)
-
-                    elif item_name == ItemName.ArmorSlotUp:
-                        current_armor_slots = self.kh2_read_byte(self.Save + 0x2500)
-                        if current_armor_slots != self.base_armor_slots + amount_of_items:
-                            if 4 > current_armor_slots < self.base_armor_slots + amount_of_items:
-                                self.kh2_write_byte(self.Save + 0x2500, current_armor_slots + 1)
-                            elif self.base_armor_slots + amount_of_items < 4:
-                                self.kh2_write_byte(self.Save + 0x2500, self.base_armor_slots + amount_of_items)
-
-                    elif item_name == ItemName.ItemSlotUp:
-                        current_item_slots = self.kh2_read_byte(self.Save + 0x2502)
-                        if current_item_slots != self.base_item_slots + amount_of_items:
-                            if 8 > current_item_slots < self.base_item_slots + amount_of_items:
-                                self.kh2_write_byte(self.Save + 0x2502, current_item_slots + 1)
-                            elif self.base_item_slots + amount_of_items < 8:
-                                self.kh2_write_byte(self.Save + 0x2502, self.base_item_slots + amount_of_items)
-                                
-                # if self.kh2_read_byte(self.Save + item_data.memaddr) != amount_of_items \
-                #        and self.kh2_read_byte(self.Slot1 + 0x1B2) >= 5 and \
-                #        self.kh2_read_byte(self.Save + 0x23DF) & 0x1 << 3 > 0 and self.kh2_read_byte(0x741320) in {10, 8}:
-                #    self.kh2_write_byte(self.Save + item_data.memaddr, amount_of_items)
 
+                # if slot1 has 5 drive gauge and goa lost illusion is checked and they are not in a cutscene
+                if self.kh2_read_byte(self.Save + item_data.memaddr) != amount_of_items \
+                        and self.kh2_read_byte(self.Slot1 + 0x1B2) >= 5 and \
+                        self.kh2_read_byte(self.Save + 0x23DF) & 0x1 << 3 > 0 and self.kh2_read_byte(0x741320) in {10, 8}:
+                    self.kh2_write_byte(self.Save + item_data.memaddr, amount_of_items)
             if "PoptrackerVersionCheck" in self.kh2slotdata:
                 if self.kh2slotdata["PoptrackerVersionCheck"] > 4.2 and self.kh2_read_byte(self.Save + 0x3607) != 1:  # telling the goa they are on version 4.3
                     self.kh2_write_byte(self.Save + 0x3607, 1)
@@ -821,8 +761,7 @@ class KH2Context(CommonContext):
 
 def finishedGame(ctx: KH2Context, message):
     if ctx.kh2slotdata['FinalXemnas'] == 1:
-        if not ctx.final_xemnas and ctx.kh2_read_byte(ctx.Save + all_world_locations[LocationName.FinalXemnas].addrObtained) \
-                & 0x1 << all_world_locations[LocationName.FinalXemnas].bitIndex > 0:
+        if not ctx.final_xemnas and ctx.kh2_loc_name_to_id[LocationName.FinalXemnas] in ctx.locations_checked:
             ctx.final_xemnas = True
     # three proofs
     if ctx.kh2slotdata['Goal'] == 0:
@@ -894,9 +833,9 @@ async def kh2_watcher(ctx: KH2Context):
                 await asyncio.create_task(ctx.verifyItems())
                 await asyncio.create_task(ctx.verifyLevel())
                 message = [{"cmd": 'LocationChecks', "locations": ctx.sending}]
-                if finishedGame(ctx, message) and not ctx.kh2_finished_game:
+                if finishedGame(ctx, message):
                     await ctx.send_msgs([{"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}])
-                    ctx.kh2_finished_game = True
+                    ctx.finished_game = True
                 await ctx.send_msgs(message)
             elif not ctx.kh2connected and ctx.serverconneced:
                 logger.info("Game Connection lost. waiting 15 seconds until trying to reconnect.")

worlds/kh2/Items.py

@@ -2,7 +2,22 @@ import typing
 
 from BaseClasses import Item
 from .Names import ItemName
-from .Subclasses import ItemData
+
+
+class KH2Item(Item):
+    game: str = "Kingdom Hearts 2"
+
+
+class ItemData(typing.NamedTuple):
+    quantity: int = 0
+    kh2id: int = 0
+    # Save+ mem addr
+    memaddr: int = 0
+    # some items have bitmasks. if bitmask>0 bitor to give item else
+    bitmask: int = 0
+    # if ability then
+    ability: bool = False
+
 
 # 0x130000
 Reports_Table = {
@@ -194,7 +209,7 @@ Armor_Table = {
     ItemName.GrandRibbon:      ItemData(1, 157, 0x35D4),
 }
 Usefull_Table = {
-    ItemName.MickeyMunnyPouch: ItemData(1, 535, 0x3695),  # 5000 munny per
+    ItemName.MickeyMunnyPouch:  ItemData(1, 535, 0x3695),  # 5000 munny per
     ItemName.OletteMunnyPouch: ItemData(2, 362, 0x363C),  # 2500 munny per
     ItemName.HadesCupTrophy:   ItemData(1, 537, 0x3696),
     ItemName.UnknownDisk:      ItemData(1, 462, 0x365F),
@@ -334,7 +349,7 @@ GoofyAbility_Table = {
 
 Wincon_Table = {
     ItemName.LuckyEmblem: ItemData(kh2id=367, memaddr=0x3641),  # letter item
-    # ItemName.Victory:     ItemData(kh2id=263, memaddr=0x111),
+    ItemName.Victory:     ItemData(kh2id=263, memaddr=0x111),
     ItemName.Bounty:      ItemData(kh2id=461, memaddr=0x365E),  # Dummy 14
     # ItemName.UniversalKey:ItemData(,365,0x363F,0)#Tournament Poster
 }

worlds/kh2/Locations.py

@@ -1,9 +1,19 @@
 import typing
 
 from BaseClasses import Location
-from .Names import LocationName, ItemName, RegionName
-from .Subclasses import LocationData
-from .Regions import KH2REGIONS
+from .Names import LocationName, ItemName
+
+
+class KH2Location(Location):
+    game: str = "Kingdom Hearts 2"
+
+
+class LocationData(typing.NamedTuple):
+    locid: int
+    yml: str
+    charName: str = "Sora"
+    charNumber: int = 1
+
 
 # data's addrcheck sys3 addr obtained roomid bit index is eventid
 LoD_Checks = {
@@ -531,7 +541,7 @@ TWTNW_Checks = {
     LocationName.Xemnas1:                               LocationData(26, "Double Get Bonus"),
     LocationName.Xemnas1GetBonus:                       LocationData(26, "Second Get Bonus"),
     LocationName.Xemnas1SecretAnsemReport13:            LocationData(537, "Chest"),
-    # LocationName.FinalXemnas:                           LocationData(71, "Get Bonus"),
+    LocationName.FinalXemnas:                           LocationData(71, "Get Bonus"),
     LocationName.XemnasDataPowerBoost:                  LocationData(554, "Chest"),
 }
 
@@ -796,75 +806,74 @@ Atlantica_Checks = {
 }
 
 event_location_to_item = {
-    LocationName.HostileProgramEventLocation:    ItemName.HostileProgramEvent,
-    LocationName.McpEventLocation:               ItemName.McpEvent,
+    LocationName.HostileProgramEventLocation:        ItemName.HostileProgramEvent,
+    LocationName.McpEventLocation:                   ItemName.McpEvent,
     # LocationName.ASLarxeneEventLocation:             ItemName.ASLarxeneEvent,
-    LocationName.DataLarxeneEventLocation:       ItemName.DataLarxeneEvent,
-    LocationName.BarbosaEventLocation:           ItemName.BarbosaEvent,
-    LocationName.GrimReaper1EventLocation:       ItemName.GrimReaper1Event,
-    LocationName.GrimReaper2EventLocation:       ItemName.GrimReaper2Event,
-    LocationName.DataLuxordEventLocation:        ItemName.DataLuxordEvent,
-    LocationName.DataAxelEventLocation:          ItemName.DataAxelEvent,
-    LocationName.CerberusEventLocation:          ItemName.CerberusEvent,
-    LocationName.OlympusPeteEventLocation:       ItemName.OlympusPeteEvent,
-    LocationName.HydraEventLocation:             ItemName.HydraEvent,
+    LocationName.DataLarxeneEventLocation:           ItemName.DataLarxeneEvent,
+    LocationName.BarbosaEventLocation:               ItemName.BarbosaEvent,
+    LocationName.GrimReaper1EventLocation:           ItemName.GrimReaper1Event,
+    LocationName.GrimReaper2EventLocation:           ItemName.GrimReaper2Event,
+    LocationName.DataLuxordEventLocation:            ItemName.DataLuxordEvent,
+    LocationName.DataAxelEventLocation:              ItemName.DataAxelEvent,
+    LocationName.CerberusEventLocation:              ItemName.CerberusEvent,
+    LocationName.OlympusPeteEventLocation:           ItemName.OlympusPeteEvent,
+    LocationName.HydraEventLocation:                 ItemName.HydraEvent,
     LocationName.OcPainAndPanicCupEventLocation: ItemName.OcPainAndPanicCupEvent,
-    LocationName.OcCerberusCupEventLocation:     ItemName.OcCerberusCupEvent,
-    LocationName.HadesEventLocation:             ItemName.HadesEvent,
+    LocationName.OcCerberusCupEventLocation:       ItemName.OcCerberusCupEvent,
+    LocationName.HadesEventLocation:                 ItemName.HadesEvent,
     # LocationName.ASZexionEventLocation:              ItemName.ASZexionEvent,
-    LocationName.DataZexionEventLocation:        ItemName.DataZexionEvent,
-    LocationName.Oc2TitanCupEventLocation:       ItemName.Oc2TitanCupEvent,
-    LocationName.Oc2GofCupEventLocation:         ItemName.Oc2GofCupEvent,
+    LocationName.DataZexionEventLocation:            ItemName.DataZexionEvent,
+    LocationName.Oc2TitanCupEventLocation:         ItemName.Oc2TitanCupEvent,
+    LocationName.Oc2GofCupEventLocation:           ItemName.Oc2GofCupEvent,
     # LocationName.Oc2CupsEventLocation:               ItemName.Oc2CupsEventLocation,
-    LocationName.HadesCupEventLocations:         ItemName.HadesCupEvents,
-    LocationName.PrisonKeeperEventLocation:      ItemName.PrisonKeeperEvent,
-    LocationName.OogieBoogieEventLocation:       ItemName.OogieBoogieEvent,
-    LocationName.ExperimentEventLocation:        ItemName.ExperimentEvent,
+    LocationName.HadesCupEventLocations:             ItemName.HadesCupEvents,
+    LocationName.PrisonKeeperEventLocation:          ItemName.PrisonKeeperEvent,
+    LocationName.OogieBoogieEventLocation:           ItemName.OogieBoogieEvent,
+    LocationName.ExperimentEventLocation:            ItemName.ExperimentEvent,
     # LocationName.ASVexenEventLocation:               ItemName.ASVexenEvent,
-    LocationName.DataVexenEventLocation:         ItemName.DataVexenEvent,
-    LocationName.ShanYuEventLocation:            ItemName.ShanYuEvent,
-    LocationName.AnsemRikuEventLocation:         ItemName.AnsemRikuEvent,
-    LocationName.StormRiderEventLocation:        ItemName.StormRiderEvent,
-    LocationName.DataXigbarEventLocation:        ItemName.DataXigbarEvent,
-    LocationName.RoxasEventLocation:             ItemName.RoxasEvent,
-    LocationName.XigbarEventLocation:            ItemName.XigbarEvent,
-    LocationName.LuxordEventLocation:            ItemName.LuxordEvent,
-    LocationName.SaixEventLocation:              ItemName.SaixEvent,
-    LocationName.XemnasEventLocation:            ItemName.XemnasEvent,
-    LocationName.ArmoredXemnasEventLocation:     ItemName.ArmoredXemnasEvent,
-    LocationName.ArmoredXemnas2EventLocation:    ItemName.ArmoredXemnas2Event,
+    LocationName.DataVexenEventLocation:             ItemName.DataVexenEvent,
+    LocationName.ShanYuEventLocation:                ItemName.ShanYuEvent,
+    LocationName.AnsemRikuEventLocation:             ItemName.AnsemRikuEvent,
+    LocationName.StormRiderEventLocation:            ItemName.StormRiderEvent,
+    LocationName.DataXigbarEventLocation:            ItemName.DataXigbarEvent,
+    LocationName.RoxasEventLocation:                 ItemName.RoxasEvent,
+    LocationName.XigbarEventLocation:                ItemName.XigbarEvent,
+    LocationName.LuxordEventLocation:                ItemName.LuxordEvent,
+    LocationName.SaixEventLocation:                  ItemName.SaixEvent,
+    LocationName.XemnasEventLocation:                ItemName.XemnasEvent,
+    LocationName.ArmoredXemnasEventLocation:         ItemName.ArmoredXemnasEvent,
+    LocationName.ArmoredXemnas2EventLocation:        ItemName.ArmoredXemnas2Event,
     # LocationName.FinalXemnasEventLocation:           ItemName.FinalXemnasEvent,
-    LocationName.DataXemnasEventLocation:        ItemName.DataXemnasEvent,
-    LocationName.ThresholderEventLocation:       ItemName.ThresholderEvent,
-    LocationName.BeastEventLocation:             ItemName.BeastEvent,
-    LocationName.DarkThornEventLocation:         ItemName.DarkThornEvent,
-    LocationName.XaldinEventLocation:            ItemName.XaldinEvent,
-    LocationName.DataXaldinEventLocation:        ItemName.DataXaldinEvent,
-    LocationName.TwinLordsEventLocation:         ItemName.TwinLordsEvent,
-    LocationName.GenieJafarEventLocation:        ItemName.GenieJafarEvent,
+    LocationName.DataXemnasEventLocation:            ItemName.DataXemnasEvent,
+    LocationName.ThresholderEventLocation:           ItemName.ThresholderEvent,
+    LocationName.BeastEventLocation:                 ItemName.BeastEvent,
+    LocationName.DarkThornEventLocation:             ItemName.DarkThornEvent,
+    LocationName.XaldinEventLocation:                ItemName.XaldinEvent,
+    LocationName.DataXaldinEventLocation:            ItemName.DataXaldinEvent,
+    LocationName.TwinLordsEventLocation:             ItemName.TwinLordsEvent,
+    LocationName.GenieJafarEventLocation:            ItemName.GenieJafarEvent,
     # LocationName.ASLexaeusEventLocation:             ItemName.ASLexaeusEvent,
-    LocationName.DataLexaeusEventLocation:       ItemName.DataLexaeusEvent,
-    LocationName.ScarEventLocation:              ItemName.ScarEvent,
-    LocationName.GroundShakerEventLocation:      ItemName.GroundShakerEvent,
-    LocationName.DataSaixEventLocation:          ItemName.DataSaixEvent,
-    LocationName.HBDemyxEventLocation:           ItemName.HBDemyxEvent,
-    LocationName.ThousandHeartlessEventLocation: ItemName.ThousandHeartlessEvent,
-    LocationName.Mushroom13EventLocation:        ItemName.Mushroom13Event,
-    LocationName.SephiEventLocation:             ItemName.SephiEvent,
-    LocationName.DataDemyxEventLocation:         ItemName.DataDemyxEvent,
-    LocationName.CorFirstFightEventLocation:     ItemName.CorFirstFightEvent,
-    LocationName.CorSecondFightEventLocation:    ItemName.CorSecondFightEvent,
-    LocationName.TransportEventLocation:         ItemName.TransportEvent,
-    LocationName.OldPeteEventLocation:           ItemName.OldPeteEvent,
-    LocationName.FuturePeteEventLocation:        ItemName.FuturePeteEvent,
+    LocationName.DataLexaeusEventLocation:           ItemName.DataLexaeusEvent,
+    LocationName.ScarEventLocation:                  ItemName.ScarEvent,
+    LocationName.GroundShakerEventLocation:          ItemName.GroundShakerEvent,
+    LocationName.DataSaixEventLocation:              ItemName.DataSaixEvent,
+    LocationName.HBDemyxEventLocation:               ItemName.HBDemyxEvent,
+    LocationName.ThousandHeartlessEventLocation:     ItemName.ThousandHeartlessEvent,
+    LocationName.Mushroom13EventLocation:            ItemName.Mushroom13Event,
+    LocationName.SephiEventLocation:                 ItemName.SephiEvent,
+    LocationName.DataDemyxEventLocation:             ItemName.DataDemyxEvent,
+    LocationName.CorFirstFightEventLocation:         ItemName.CorFirstFightEvent,
+    LocationName.CorSecondFightEventLocation:        ItemName.CorSecondFightEvent,
+    LocationName.TransportEventLocation:             ItemName.TransportEvent,
+    LocationName.OldPeteEventLocation:               ItemName.OldPeteEvent,
+    LocationName.FuturePeteEventLocation:            ItemName.FuturePeteEvent,
     # LocationName.ASMarluxiaEventLocation:            ItemName.ASMarluxiaEvent,
-    LocationName.DataMarluxiaEventLocation:      ItemName.DataMarluxiaEvent,
-    LocationName.TerraEventLocation:             ItemName.TerraEvent,
-    LocationName.TwilightThornEventLocation:     ItemName.TwilightThornEvent,
-    LocationName.Axel1EventLocation:             ItemName.Axel1Event,
-    LocationName.Axel2EventLocation:             ItemName.Axel2Event,
-    LocationName.DataRoxasEventLocation:         ItemName.DataRoxasEvent,
-    LocationName.FinalXemnasEventLocation:       ItemName.Victory,
+    LocationName.DataMarluxiaEventLocation:          ItemName.DataMarluxiaEvent,
+    LocationName.TerraEventLocation:                 ItemName.TerraEvent,
+    LocationName.TwilightThornEventLocation:         ItemName.TwilightThornEvent,
+    LocationName.Axel1EventLocation:                 ItemName.Axel1Event,
+    LocationName.Axel2EventLocation:                 ItemName.Axel2Event,
+    LocationName.DataRoxasEventLocation:             ItemName.DataRoxasEvent,
 }
 all_weapon_slot = {
     LocationName.FAKESlot,
@@ -1352,9 +1361,3 @@ exclusion_table = {
         location for location, data in all_locations.items() if location not in event_location_to_item.keys() and location not in popups_set and location != LocationName.StationofSerenityPotion and data.yml == "Chest"
     }
 }
-
-location_groups: typing.Dict[str, list]
-location_groups = {
-    Region_Name: [loc for loc in Region_Locs if "Event" not in loc]
-    for Region_Name, Region_Locs in KH2REGIONS.items() if Region_Locs
-}

worlds/kh2/Options.py

@@ -2,7 +2,7 @@ from dataclasses import dataclass
 
 from Options import Choice, Range, Toggle, ItemDict, PerGameCommonOptions, StartInventoryPool
 
-from . import default_itempool_option
+from worlds.kh2 import default_itempool_option
 
 
 class SoraEXP(Range):

worlds/kh2/Regions.py

@@ -1,11 +1,9 @@
 import typing
 
 from BaseClasses import MultiWorld, Region
-from . import Locations
 
-from .Subclasses import KH2Location
-from .Names import LocationName, RegionName
-from .Items import Events_Table
+from .Locations import KH2Location, event_location_to_item
+from . import LocationName, RegionName, Events_Table
 
 KH2REGIONS: typing.Dict[str, typing.List[str]] = {
     "Menu":                        [],
@@ -790,7 +788,7 @@ KH2REGIONS: typing.Dict[str, typing.List[str]] = {
         LocationName.ArmoredXemnas2EventLocation
     ],
     RegionName.FinalXemnas:        [
-        LocationName.FinalXemnasEventLocation
+        LocationName.FinalXemnas
     ],
     RegionName.DataXemnas:         [
         LocationName.XemnasDataPowerBoost,
@@ -1022,10 +1020,10 @@ def create_regions(self):
     multiworld.regions += [create_region(multiworld, player, active_locations, region, locations) for region, locations in
                            KH2REGIONS.items()]
     # fill the event locations with events
-
-    for location, item in Locations.event_location_to_item.items():
+    multiworld.worlds[player].item_name_to_id.update({event_name: None for event_name in Events_Table})
+    for location, item in event_location_to_item.items():
         multiworld.get_location(location, player).place_locked_item(
-                multiworld.worlds[player].create_event_item(item))
+                multiworld.worlds[player].create_item(item))
 
 
 def connect_regions(self):

worlds/kh2/Rules.py

@@ -1,7 +1,7 @@
 from typing import Dict, Callable, TYPE_CHECKING
 
 from BaseClasses import CollectionState
-from .Items import exclusion_item_table, visit_locking_dict, DonaldAbility_Table, GoofyAbility_Table, SupportAbility_Table
+from .Items import exclusion_item_table, visit_locking_dict, DonaldAbility_Table, GoofyAbility_Table
 from .Locations import exclusion_table, popups_set, Goofy_Checks, Donald_Checks
 from .Names import LocationName, ItemName, RegionName
 from worlds.generic.Rules import add_rule, forbid_items, add_item_rule
@@ -83,8 +83,6 @@ class KH2Rules:
         return state.has(ItemName.TornPages, self.player, amount)
 
     def level_locking_unlock(self, state: CollectionState, amount):
-        if self.world.options.Promise_Charm and state.has(ItemName.PromiseCharm, self.player):
-            return True
         return amount <= sum([state.count(item_name, self.player) for item_name in visit_locking_dict["2VisitLocking"]])
 
     def summon_levels_unlocked(self, state: CollectionState, amount) -> bool:
@@ -226,7 +224,7 @@ class KH2WorldRules(KH2Rules):
             RegionName.Pl2:                lambda state: self.pl_unlocked(state, 2),
 
             RegionName.Ag:                 lambda state: self.ag_unlocked(state, 1),
-            RegionName.Ag2:                lambda state: self.ag_unlocked(state, 2) and self.kh2_has_all([ItemName.FireElement, ItemName.BlizzardElement, ItemName.ThunderElement], state),
+            RegionName.Ag2:                lambda state: self.ag_unlocked(state, 2),
 
             RegionName.Bc:                 lambda state: self.bc_unlocked(state, 1),
             RegionName.Bc2:                lambda state: self.bc_unlocked(state, 2),
@@ -268,11 +266,10 @@ class KH2WorldRules(KH2Rules):
                 add_item_rule(location, lambda item: item.player == self.player and item.name in GoofyAbility_Table.keys())
             elif location.name in Donald_Checks:
                 add_item_rule(location, lambda item: item.player == self.player and item.name in DonaldAbility_Table.keys())
-            else:
-                add_item_rule(location, lambda item: item.player == self.player and item.name in SupportAbility_Table.keys())
 
     def set_kh2_goal(self):
-        final_xemnas_location = self.multiworld.get_location(LocationName.FinalXemnasEventLocation, self.player)
+
+        final_xemnas_location = self.multiworld.get_location(LocationName.FinalXemnas, self.player)
         if self.multiworld.Goal[self.player] == "three_proofs":
             final_xemnas_location.access_rule = lambda state: self.kh2_has_all(three_proofs, state)
             if self.multiworld.FinalXemnas[self.player]:
@@ -294,8 +291,8 @@ class KH2WorldRules(KH2Rules):
             else:
                 self.multiworld.completion_condition[self.player] = lambda state: state.has(ItemName.Bounty, self.player, self.multiworld.BountyRequired[self.player].value)
         else:
-            final_xemnas_location.access_rule = lambda state: state.has(ItemName.Bounty, self.player, self.multiworld.BountyRequired[self.player].value) and \
-                                                              state.has(ItemName.LuckyEmblem, self.player, self.multiworld.LuckyEmblemsRequired[self.player].value)
+            final_xemnas_location.access_rule = lambda state: state.has(ItemName.Bounty, self.player, self.multiworld.BountyRequired[self.player].value) and\
+                                  state.has(ItemName.LuckyEmblem, self.player, self.multiworld.LuckyEmblemsRequired[self.player].value)
             if self.multiworld.FinalXemnas[self.player]:
                 self.multiworld.completion_condition[self.player] = lambda state: state.has(ItemName.Victory, self.player, 1)
             else:
@@ -421,7 +418,7 @@ class KH2FightRules(KH2Rules):
             RegionName.DataLexaeus:       lambda state: self.get_data_lexaeus_rules(state),
             RegionName.OldPete:           lambda state: self.get_old_pete_rules(),
             RegionName.FuturePete:        lambda state: self.get_future_pete_rules(state),
-            RegionName.Terra:             lambda state: self.get_terra_rules(state) and state.has(ItemName.ProofofConnection, self.player),
+            RegionName.Terra:             lambda state: self.get_terra_rules(state),
             RegionName.DataMarluxia:      lambda state: self.get_data_marluxia_rules(state),
             RegionName.Barbosa:           lambda state: self.get_barbosa_rules(state),
             RegionName.GrimReaper1:       lambda state: self.get_grim_reaper1_rules(),