Update Main

.github/workflows/build.yml

@@ -51,7 +51,7 @@ jobs:
         run: |
           Invoke-WebRequest -Uri https://github.com/Ijwu/Enemizer/releases/download/${Env:ENEMIZER_VERSION}/win-x64.zip -OutFile enemizer.zip
           Expand-Archive -Path enemizer.zip -DestinationPath EnemizerCLI -Force
-          choco install innosetup --version=6.2.2 --allow-downgrade
+          choco install innosetup --version=6.7.0 --allow-downgrade
       - name: Build
         run: |
           python -m pip install --upgrade pip

BaseClasses.py

@@ -727,6 +727,7 @@ class CollectionState():
     advancements: Set[Location]
     path: Dict[Union[Region, Entrance], PathValue]
     locations_checked: Set[Location]
+    """Internal cache for Advancement Locations already checked by this CollectionState. Not for use in logic."""
     stale: Dict[int, bool]
     allow_partial_entrances: bool
     additional_init_functions: List[Callable[[CollectionState, MultiWorld], None]] = []
@@ -788,9 +789,11 @@ def _update_reachable_regions_explicit_indirect_conditions(self, player: int, qu
                 self.multiworld.worlds[player].reached_region(self, new_region)
 
                 # 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:
-                        queue.append(new_entrance)
+                entrances = self.multiworld.indirect_connections.get(new_region)
+                if entrances is not None:
+                    relevant_entrances = entrances.intersection(blocked_connections)
+                    relevant_entrances.difference_update(queue)
+                    queue.extend(relevant_entrances)
 
     def _update_reachable_regions_auto_indirect_conditions(self, player: int, queue: deque[Entrance]):
         reachable_regions = self.reachable_regions[player]

Fill.py

@@ -280,6 +280,7 @@ def location_can_fill_item(location_to_fill: Location, item_to_fill: Item):
         item_to_place = itempool.pop()
         spot_to_fill: typing.Optional[Location] = None
 
+        # going through locations in the same order as the provided `locations` argument
         for i, location in enumerate(locations):
             if location_can_fill_item(location, item_to_place):
                 # popping by index is faster than removing by content,

Main.py

@@ -207,6 +207,9 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
     else:
         logger.info("Progression balancing skipped.")
 
+    AutoWorld.call_all(multiworld, "finalize_multiworld")
+    AutoWorld.call_all(multiworld, "pre_output")
+
     # we're about to output using multithreading, so we're removing the global random state to prevent accidental use
     multiworld.random.passthrough = False
 

MultiServer.py

@@ -21,6 +21,7 @@
 import typing
 import weakref
 import zlib
+from signal import SIGINT, SIGTERM, signal
 
 import ModuleUpdate
 
@@ -496,7 +497,8 @@ def _load(self, decoded_obj: MultiData, game_data_packages: typing.Dict[str, typ
 
         self.read_data = {}
         # there might be a better place to put this.
-        self.read_data["race_mode"] = lambda: decoded_obj.get("race_mode", 0)
+        race_mode = decoded_obj.get("race_mode", 0)
+        self.read_data["race_mode"] = lambda: race_mode
         mdata_ver = decoded_obj["minimum_versions"]["server"]
         if mdata_ver > version_tuple:
             raise RuntimeError(f"Supplied Multidata (.archipelago) requires a server of at least version {mdata_ver}, "
@@ -1301,6 +1303,13 @@ def __new__(cls, name, bases, attrs):
             commands.update(base.commands)
         commands.update({command_name[5:]: method for command_name, method in attrs.items() if
                          command_name.startswith("_cmd_")})
+        for command_name, method in commands.items():
+            # wrap async def functions so they run on default asyncio loop
+            if inspect.iscoroutinefunction(method):
+                def _wrapper(self, *args, _method=method, **kwargs):
+                    return async_start(_method(self, *args, **kwargs))
+                functools.update_wrapper(_wrapper, method)
+                commands[command_name] = _wrapper
         return super(CommandMeta, cls).__new__(cls, name, bases, attrs)
 
 
@@ -2563,6 +2572,8 @@ async def console(ctx: Context):
             input_text = await queue.get()
             queue.task_done()
             ctx.commandprocessor(input_text)
+        except asyncio.exceptions.CancelledError:
+            ctx.logger.info("ConsoleTask cancelled")
         except:
             import traceback
             traceback.print_exc()
@@ -2729,6 +2740,26 @@ async def main(args: argparse.Namespace):
     console_task = asyncio.create_task(console(ctx))
     if ctx.auto_shutdown:
         ctx.shutdown_task = asyncio.create_task(auto_shutdown(ctx, [console_task]))
+
+    def stop():
+        try:
+            for remove_signal in [SIGINT, SIGTERM]:
+                asyncio.get_event_loop().remove_signal_handler(remove_signal)
+        except NotImplementedError:
+            pass
+        ctx.commandprocessor._cmd_exit()
+
+    def shutdown(signum, frame):
+        stop()
+
+    try:
+        for sig in [SIGINT, SIGTERM]:
+            asyncio.get_event_loop().add_signal_handler(sig, stop)
+    except NotImplementedError:
+        # add_signal_handler is only implemented for UNIX platforms
+        for sig in [SIGINT, SIGTERM]:
+            signal(sig, shutdown)
+
     await ctx.exit_event.wait()
     console_task.cancel()
     if ctx.shutdown_task:

OptionsCreator.py

@@ -29,7 +29,7 @@
 import re
 from urllib.parse import urlparse
 from worlds.AutoWorld import AutoWorldRegister, World
-from Options import (Option, Toggle, TextChoice, Choice, FreeText, NamedRange, Range, OptionSet, OptionList, Removed,
+from Options import (Option, Toggle, TextChoice, Choice, FreeText, NamedRange, Range, OptionSet, OptionList,
                      OptionCounter, Visibility)
 
 
@@ -318,26 +318,28 @@ def export_options(self, button: Widget) -> None:
         else:
             self.show_result_snack("Name cannot be longer than 16 characters.")
 
-    def create_range(self, option: typing.Type[Range], name: str):
+    def create_range(self, option: typing.Type[Range], name: str, bind=True):
         def update_text(range_box: VisualRange):
             self.options[name] = int(range_box.slider.value)
             range_box.tag.text = str(int(range_box.slider.value))
             return
 
         box = VisualRange(option=option, name=name)
-        box.slider.bind(on_touch_move=lambda _, _1: update_text(box))
+        if bind:
+            box.slider.bind(value=lambda _, _1: update_text(box))
         self.options[name] = option.default
         return box
 
     def create_named_range(self, option: typing.Type[NamedRange], name: str):
         def set_to_custom(range_box: VisualNamedRange):
-            if (not self.options[name] == range_box.range.slider.value) \
-                    and (not self.options[name] in option.special_range_names or
-                         range_box.range.slider.value != option.special_range_names[self.options[name]]):
-                # we should validate the touch here,
-                # but this is much cheaper
+            range_box.range.tag.text = str(int(range_box.range.slider.value))
+            if range_box.range.slider.value in option.special_range_names.values():
+                value = next(key for key, val in option.special_range_names.items()
+                             if val == range_box.range.slider.value)
+                self.options[name] = value
+                set_button_text(box.choice, value.title())
+            else:
                 self.options[name] = int(range_box.range.slider.value)
-                range_box.range.tag.text = str(int(range_box.range.slider.value))
                 set_button_text(range_box.choice, "Custom")
 
         def set_button_text(button: MDButton, text: str):
@@ -346,7 +348,7 @@ def set_button_text(button: MDButton, text: str):
         def set_value(text: str, range_box: VisualNamedRange):
             range_box.range.slider.value = min(max(option.special_range_names[text.lower()], option.range_start),
                                                option.range_end)
-            range_box.range.tag.text = str(int(range_box.range.slider.value))
+            range_box.range.tag.text = str(option.special_range_names[text.lower()])
             set_button_text(range_box.choice, text)
             self.options[name] = text.lower()
             range_box.range.slider.dropdown.dismiss()
@@ -355,13 +357,18 @@ def open_dropdown(button):
             # for some reason this fixes an issue causing some to not open
             box.range.slider.dropdown.open()
 
-        box = VisualNamedRange(option=option, name=name, range_widget=self.create_range(option, name))
-        if option.default in option.special_range_names:
+        box = VisualNamedRange(option=option, name=name, range_widget=self.create_range(option, name, bind=False))
+        default: int | str = option.default
+        if default in option.special_range_names:
             # value can get mismatched in this case
-            box.range.slider.value = min(max(option.special_range_names[option.default], option.range_start),
+            box.range.slider.value = min(max(option.special_range_names[default], option.range_start),
                                                option.range_end)
             box.range.tag.text = str(int(box.range.slider.value))
-        box.range.slider.bind(on_touch_move=lambda _, _2: set_to_custom(box))
+        elif default in option.special_range_names.values():
+            # better visual
+            default = next(key for key, val in option.special_range_names.items() if val == option.default)
+            set_button_text(box.choice, default.title())
+        box.range.slider.bind(value=lambda _, _2: set_to_custom(box))
         items = [
             {
                 "text": choice.title(),
@@ -371,7 +378,7 @@ def open_dropdown(button):
         ]
         box.range.slider.dropdown = MDDropdownMenu(caller=box.choice, items=items)
         box.choice.bind(on_release=open_dropdown)
-        self.options[name] = option.default
+        self.options[name] = default
         return box
 
     def create_free_text(self, option: typing.Type[FreeText] | typing.Type[TextChoice], name: str):
@@ -447,8 +454,12 @@ def create_popup(self, option: typing.Type[OptionList] | typing.Type[OptionSet]
         valid_keys = sorted(option.valid_keys)
         if option.verify_item_name:
             valid_keys += list(world.item_name_to_id.keys())
+            if option.convert_name_groups:
+                valid_keys += list(world.item_name_groups.keys())
         if option.verify_location_name:
             valid_keys += list(world.location_name_to_id.keys())
+            if option.convert_name_groups:
+                valid_keys += list(world.location_name_groups.keys())
 
         if not issubclass(option, OptionCounter):
             def apply_changes(button):
@@ -470,14 +481,6 @@ def apply_changes(button):
         dialog.scrollbox.layout.spacing = dp(5)
         dialog.scrollbox.layout.padding = [0, dp(5), 0, 0]
 
-        if name not in self.options:
-            # convert from non-mutable to mutable
-            # We use list syntax even for sets, set behavior is enforced through GUI
-            if issubclass(option, OptionCounter):
-                self.options[name] = deepcopy(option.default)
-            else:
-                self.options[name] = sorted(option.default)
-
         if issubclass(option, OptionCounter):
             for value in sorted(self.options[name]):
                 dialog.add_set_item(value, self.options[name].get(value, None))
@@ -491,6 +494,15 @@ def apply_changes(button):
     def create_option_set_list_counter(self, option: typing.Type[OptionList] | typing.Type[OptionSet] |
                                        typing.Type[OptionCounter], name: str, world: typing.Type[World]):
         main_button = MDButton(MDButtonText(text="Edit"), on_release=lambda x: self.create_popup(option, name, world))
+
+        if name not in self.options:
+            # convert from non-mutable to mutable
+            # We use list syntax even for sets, set behavior is enforced through GUI
+            if issubclass(option, OptionCounter):
+                self.options[name] = deepcopy(option.default)
+            else:
+                self.options[name] = sorted(option.default)
+
         return main_button
 
     def create_option(self, option: typing.Type[Option], name: str, world: typing.Type[World]) -> Widget:

README.md

@@ -85,6 +85,7 @@ Currently, the following games are supported:
 * APQuest
 * Satisfactory
 * EarthBound
+* Mega Man 3
 
 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