Make webhost directly executable

* Tests: Add checksum validation to the postgen datapackage test

* add a special case for the test world datapackage rather than hidden

* add the test world to the datapackage instead of special casing around it

---------

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

AdventureClient.py

@@ -80,7 +80,7 @@ class AdventureContext(CommonContext):
         self.local_item_locations = {}
         self.dragon_speed_info = {}
 
-        options = Utils.get_options()
+        options = Utils.get_settings()
         self.display_msgs = options["adventure_options"]["display_msgs"]
 
     async def server_auth(self, password_requested: bool = False):
@@ -102,7 +102,7 @@ class AdventureContext(CommonContext):
     def on_package(self, cmd: str, args: dict):
         if cmd == 'Connected':
             self.locations_array = None
-            if Utils.get_options()["adventure_options"].get("death_link", False):
+            if Utils.get_settings()["adventure_options"].get("death_link", False):
                 self.set_deathlink = True
             async_start(self.get_freeincarnates_used())
         elif cmd == "RoomInfo":
@@ -415,8 +415,8 @@ async def atari_sync_task(ctx: AdventureContext):
 
 
 async def run_game(romfile):
-    auto_start = Utils.get_options()["adventure_options"].get("rom_start", True)
+    auto_start = Utils.get_settings()["adventure_options"].get("rom_start", True)
-    rom_args = Utils.get_options()["adventure_options"].get("rom_args")
+    rom_args = Utils.get_settings()["adventure_options"].get("rom_args")
     if auto_start is True:
         import webbrowser
         webbrowser.open(romfile)

CommonClient.py

@@ -494,6 +494,11 @@ class CommonContext:
         Returned text is sent, or sending is aborted if None is returned."""
         return text
     
+    def on_ui_command(self, text: str) -> None:
+        """Gets called by kivy when the user executes a command starting with `/` or `!`.
+        The command processor is still called; this is just intended for command echoing."""
+        self.ui.print_json([{"text": text, "type": "color", "color": "orange"}])
+
     def update_permissions(self, permissions: typing.Dict[str, int]):
         for permission_name, permission_flag in permissions.items():
             try:

Generate.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
 import argparse
+import copy
 import logging
 import os
 import random
 import string
+import sys
 import urllib.parse
 import urllib.request
 from collections import Counter
@@ -15,21 +17,16 @@ import ModuleUpdate
 
 ModuleUpdate.update()
 
-import copy
 import Utils
 import Options
 from BaseClasses import seeddigits, get_seed, PlandoOptions
-from Main import main as ERmain
-from settings import get_settings
 from Utils import parse_yamls, version_tuple, __version__, tuplize_version
-from worlds.alttp.EntranceRandomizer import parse_arguments
-from worlds.AutoWorld import AutoWorldRegister
-from worlds import failed_world_loads
 
 
 def mystery_argparse():
-    options = get_settings()
+    from settings import get_settings
-    defaults = options.generator
+    settings = get_settings()
+    defaults = settings.generator
 
     parser = argparse.ArgumentParser(description="CMD Generation Interface, defaults come from host.yaml.")
     parser.add_argument('--weights_file_path', default=defaults.weights_file_path,
@@ -41,7 +38,7 @@ def mystery_argparse():
     parser.add_argument('--seed', help='Define seed number to generate.', type=int)
     parser.add_argument('--multi', default=defaults.players, type=lambda value: max(int(value), 1))
     parser.add_argument('--spoiler', type=int, default=defaults.spoiler)
-    parser.add_argument('--outputpath', default=options.general_options.output_path,
+    parser.add_argument('--outputpath', default=settings.general_options.output_path,
                         help="Path to output folder. Absolute or relative to cwd.")  # absolute or relative to cwd
     parser.add_argument('--race', action='store_true', default=defaults.race)
     parser.add_argument('--meta_file_path', default=defaults.meta_file_path)
@@ -61,20 +58,21 @@ def mystery_argparse():
     if not os.path.isabs(args.meta_file_path):
         args.meta_file_path = os.path.join(args.player_files_path, args.meta_file_path)
     args.plando: PlandoOptions = PlandoOptions.from_option_string(args.plando)
-    return args, options
+    return args
 
 
 def get_seed_name(random_source) -> str:
     return f"{random_source.randint(0, pow(10, seeddigits) - 1)}".zfill(seeddigits)
 
 
-def main(args=None, callback=ERmain):
+def main(args=None):
     if not args:
-        args, options = mystery_argparse()
+        args = mystery_argparse()
-    else:
-        options = get_settings()
 
     seed = get_seed(args.seed)
+    # __name__ == "__main__" check so unittests that already imported worlds don't trip this.
+    if __name__ == "__main__" and "worlds" in sys.modules:
+        raise Exception("Worlds system should not be loaded before logging init.")
     Utils.init_logging(f"Generate_{seed}", loglevel=args.log_level)
     random.seed(seed)
     seed_name = get_seed_name(random)
@@ -143,6 +141,9 @@ def main(args=None, callback=ERmain):
         raise Exception(f"No weights found. "
                         f"Provide a general weights file ({args.weights_file_path}) or individual player files. "
                         f"A mix is also permitted.")
+
+    from worlds.AutoWorld import AutoWorldRegister
+    from worlds.alttp.EntranceRandomizer import parse_arguments
     erargs = parse_arguments(['--multi', str(args.multi)])
     erargs.seed = seed
     erargs.plando_options = args.plando
@@ -234,7 +235,8 @@ def main(args=None, callback=ERmain):
         with open(os.path.join(args.outputpath if args.outputpath else ".", f"generate_{seed_name}.yaml"), "wt") as f:
             yaml.dump(important, f)
 
-    return callback(erargs, seed)
+    from Main import main as ERmain
+    return ERmain(erargs, seed)
 
 
 def read_weights_yamls(path) -> Tuple[Any, ...]:
@@ -359,6 +361,8 @@ def update_weights(weights: dict, new_weights: dict, update_type: str, name: str
 
 
 def roll_meta_option(option_key, game: str, category_dict: Dict) -> Any:
+    from worlds import AutoWorldRegister
+
     if not game:
         return get_choice(option_key, category_dict)
     if game in AutoWorldRegister.world_types:
@@ -436,10 +440,13 @@ def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str,
     except Exception as e:
         raise Options.OptionError(f"Error generating option {option_key} in {ret.game}") from e
     else:
+        from worlds import AutoWorldRegister
         player_option.verify(AutoWorldRegister.world_types[ret.game], ret.name, plando_options)
 
 
 def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.bosses):
+    from worlds import AutoWorldRegister
+
     if "linked_options" in weights:
         weights = roll_linked_options(weights)
 
@@ -466,6 +473,7 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
 
     ret.game = get_choice("game", weights)
     if ret.game not in AutoWorldRegister.world_types:
+        from worlds import failed_world_loads
         picks = Utils.get_fuzzy_results(ret.game, list(AutoWorldRegister.world_types) + failed_world_loads, limit=1)[0]
         if picks[0] in failed_world_loads:
             raise Exception(f"No functional world found to handle game {ret.game}. "

NetUtils.py

@@ -198,7 +198,8 @@ class JSONtoTextParser(metaclass=HandlerMeta):
         "slateblue": "6D8BE8",
         "plum": "AF99EF",
         "salmon": "FA8072",
-        "white": "FFFFFF"
+        "white": "FFFFFF",
+        "orange": "FF7700",
     }
 
     def __init__(self, ctx):

Utils.py

@@ -553,6 +553,7 @@ def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO, wri
         f"Archipelago ({__version__}) logging initialized"
         f" on {platform.platform()}"
         f" running Python {sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+        f"{' (frozen)' if is_frozen() else ''}"
     )
 
 

WebHost.py

@@ -1,3 +1,5 @@
+#!/usr/bin/env python3
+
 import os
 import multiprocessing
 import logging

data/client.kv

@@ -13,6 +13,7 @@
     plum: "AF99EF"  # typically progression item
     salmon: "FA8072"  # typically trap item
     white: "FFFFFF"  # not used, if you want to change the generic text color change color in Label
+    orange: "FF7700"  # Used for command echo
 <Label>:
     color: "FFFFFF"
 <TabbedPanel>:

inno_setup.iss

@@ -89,6 +89,9 @@ Type: files; Name: "{app}\ArchipelagoPokemonClient.exe"
 Type: files; Name: "{app}\data\lua\connector_pkmn_rb.lua"
 Type: filesandordirs; Name: "{app}\lib\worlds\rogue-legacy"
 Type: dirifempty; Name: "{app}\lib\worlds\rogue-legacy"
+Type: files; Name: "{app}\lib\worlds\sc2wol.apworld"
+Type: filesandordirs; Name: "{app}\lib\worlds\sc2wol"
+Type: dirifempty; Name: "{app}\lib\worlds\sc2wol"
 Type: filesandordirs; Name: "{app}\lib\worlds\bk_sudoku"
 Type: dirifempty; Name: "{app}\lib\worlds\bk_sudoku"
 Type: files; Name: "{app}\ArchipelagoLauncher(DEBUG).exe"

kvui.py

@@ -3,6 +3,7 @@ import logging
 import sys
 import typing
 import re
+from collections import deque
 
 if sys.platform == "win32":
     import ctypes
@@ -380,6 +381,57 @@ class ConnectBarTextInput(TextInput):
         return super(ConnectBarTextInput, self).insert_text(s, from_undo=from_undo)
 
 
+def is_command_input(string: str) -> bool:
+    return len(string) > 0 and string[0] in "/!"
+
+
+class CommandPromptTextInput(TextInput):
+    MAXIMUM_HISTORY_MESSAGES = 50
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._command_history_index = -1
+        self._command_history: typing.Deque[str] = deque(maxlen=CommandPromptTextInput.MAXIMUM_HISTORY_MESSAGES)
+    
+    def update_history(self, new_entry: str) -> None:
+        self._command_history_index = -1
+        if is_command_input(new_entry):
+            self._command_history.appendleft(new_entry)
+
+    def keyboard_on_key_down(
+        self,
+        window,
+        keycode: typing.Tuple[int, str],
+        text: typing.Optional[str],
+        modifiers: typing.List[str]
+    ) -> bool:
+        """
+        :param window: The kivy window object
+        :param keycode: A tuple of (keycode, keyname). Keynames are always lowercase
+        :param text: The text printed by this key, not accounting for modifiers, or `None` if no text.
+                     Seems to pretty naively interpret the keycode as unicode, so numlock can return odd characters.
+        :param modifiers: A list of string modifiers, like `ctrl` or `numlock`
+        """
+        if keycode[1] == 'up':
+            self._change_to_history_text_if_available(self._command_history_index + 1)
+            return True
+        if keycode[1] == 'down':
+            self._change_to_history_text_if_available(self._command_history_index - 1)
+            return True
+        return super().keyboard_on_key_down(window, keycode, text, modifiers)
+    
+    def _change_to_history_text_if_available(self, new_index: int) -> None:
+        if new_index < -1:
+            return
+        if new_index >= len(self._command_history):
+            return
+        self._command_history_index = new_index
+        if new_index == -1:
+            self.text = ""
+            return
+        self.text = self._command_history[self._command_history_index]
+
+
 class MessageBox(Popup):
     class MessageBoxLabel(Label):
         def __init__(self, **kwargs):
@@ -415,7 +467,7 @@ class GameManager(App):
         self.commandprocessor = ctx.command_processor(ctx)
         self.icon = r"data/icon.png"
         self.json_to_kivy_parser = KivyJSONtoTextParser(ctx)
-        self.log_panels = {}
+        self.log_panels: typing.Dict[str, Widget] = {}
 
         # keep track of last used command to autofill on click
         self.last_autofillable_command = "hint"
@@ -499,7 +551,7 @@ class GameManager(App):
         info_button = Button(size=(dp(100), dp(30)), text="Command:", size_hint_x=None)
         info_button.bind(on_release=self.command_button_action)
         bottom_layout.add_widget(info_button)
-        self.textinput = TextInput(size_hint_y=None, height=dp(30), multiline=False, write_tab=False)
+        self.textinput = CommandPromptTextInput(size_hint_y=None, height=dp(30), multiline=False, write_tab=False)
         self.textinput.bind(on_text_validate=self.on_message)
         self.textinput.text_validate_unfocus = False
         bottom_layout.add_widget(self.textinput)
@@ -557,14 +609,18 @@ class GameManager(App):
 
         self.ctx.exit_event.set()
 
-    def on_message(self, textinput: TextInput):
+    def on_message(self, textinput: CommandPromptTextInput):
         try:
             input_text = textinput.text.strip()
             textinput.text = ""
+            textinput.update_history(input_text)
 
             if self.ctx.input_requests > 0:
                 self.ctx.input_requests -= 1
                 self.ctx.input_queue.put_nowait(input_text)
+            elif is_command_input(input_text):
+                self.ctx.on_ui_command(input_text)
+                self.commandprocessor(input_text)
             elif input_text:
                 self.commandprocessor(input_text)
 

test/general/__init__.py

@@ -2,6 +2,7 @@ from argparse import Namespace
 from typing import List, Optional, Tuple, Type, Union
 
 from BaseClasses import CollectionState, Item, ItemClassification, Location, MultiWorld, Region
+from worlds import network_data_package
 from worlds.AutoWorld import World, call_all
 
 gen_steps = ("generate_early", "create_regions", "create_items", "set_rules", "generate_basic", "pre_fill")
@@ -60,6 +61,10 @@ class TestWorld(World):
     hidden = True
 
 
+# add our test world to the data package, so we can test it later
+network_data_package["games"][TestWorld.game] = TestWorld.get_data_package_data()
+
+
 def generate_test_multiworld(players: int = 1) -> MultiWorld:
     """
     Generates a multiworld using a special Test Case World class, and seed of 0.

test/general/test_ids.py

@@ -1,6 +1,7 @@
 import unittest
 
 from Fill import distribute_items_restrictive
+from worlds import network_data_package
 from worlds.AutoWorld import AutoWorldRegister, call_all
 from . import setup_solo_multiworld
 
@@ -84,3 +85,4 @@ class TestIDs(unittest.TestCase):
                                           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")
+                self.assertEqual(datapackage["checksum"], network_data_package["games"][gamename]["checksum"])

worlds/__init__.py

@@ -1,4 +1,5 @@
 import importlib
+import importlib.util
 import logging
 import os
 import sys

worlds/adventure/Options.py

@@ -2,7 +2,8 @@ from __future__ import annotations
 
 from typing import Dict
 
-from Options import Choice, Option, DefaultOnToggle, DeathLink, Range, Toggle
+from dataclasses import dataclass
+from Options import Choice, Option, DefaultOnToggle, DeathLink, Range, Toggle, PerGameCommonOptions
 
 
 class FreeincarnateMax(Range):
@@ -223,22 +224,22 @@ class StartCastle(Choice):
     option_white = 2
     default = option_yellow
 
+@dataclass
+class AdventureOptions(PerGameCommonOptions):
+    dragon_slay_check: DragonSlayCheck
+    death_link: DeathLink
+    bat_logic: BatLogic
+    freeincarnate_max: FreeincarnateMax
+    dragon_rando_type: DragonRandoType
+    connector_multi_slot: ConnectorMultiSlot
+    yorgle_speed: YorgleStartingSpeed
+    yorgle_min_speed: YorgleMinimumSpeed
+    grundle_speed: GrundleStartingSpeed
+    grundle_min_speed: GrundleMinimumSpeed
+    rhindle_speed: RhindleStartingSpeed
+    rhindle_min_speed: RhindleMinimumSpeed
+    difficulty_switch_a: DifficultySwitchA
+    difficulty_switch_b: DifficultySwitchB
+    start_castle: StartCastle
 
-adventure_option_definitions: Dict[str, type(Option)] = {
-    "dragon_slay_check": DragonSlayCheck,
-    "death_link": DeathLink,
-    "bat_logic": BatLogic,
-    "freeincarnate_max": FreeincarnateMax,
-    "dragon_rando_type": DragonRandoType,
-    "connector_multi_slot": ConnectorMultiSlot,
-    "yorgle_speed": YorgleStartingSpeed,
-    "yorgle_min_speed": YorgleMinimumSpeed,
-    "grundle_speed": GrundleStartingSpeed,
-    "grundle_min_speed": GrundleMinimumSpeed,
-    "rhindle_speed": RhindleStartingSpeed,
-    "rhindle_min_speed": RhindleMinimumSpeed,
-    "difficulty_switch_a": DifficultySwitchA,
-    "difficulty_switch_b": DifficultySwitchB,
-    "start_castle": StartCastle,
 
-}

worlds/adventure/Regions.py

@@ -1,4 +1,5 @@
 from BaseClasses import MultiWorld, Region, Entrance, LocationProgressType
+from Options import PerGameCommonOptions
 from .Locations import location_table, LocationData, AdventureLocation, dragon_room_to_region
 
 
@@ -24,7 +25,7 @@ def connect(world: MultiWorld, player: int, source: str, target: str, rule: call
         connect(world, player, target, source, rule, True)
 
 
-def create_regions(multiworld: MultiWorld, player: int, dragon_rooms: []) -> None:
+def create_regions(options: PerGameCommonOptions, multiworld: MultiWorld, player: int, dragon_rooms: []) -> None:
 
     menu = Region("Menu", player, multiworld)
 
@@ -74,7 +75,7 @@ def create_regions(multiworld: MultiWorld, player: int, dragon_rooms: []) -> Non
     credits_room_far_side.exits.append(Entrance(player, "CreditsFromFarSide", credits_room_far_side))
     multiworld.regions.append(credits_room_far_side)
 
-    dragon_slay_check = multiworld.dragon_slay_check[player].value
+    dragon_slay_check = options.dragon_slay_check.value
     priority_locations = determine_priority_locations(multiworld, dragon_slay_check)
 
     for name, location_data in location_table.items():

worlds/adventure/Rules.py

@@ -6,7 +6,7 @@ from BaseClasses import LocationProgressType
 
 def set_rules(self) -> None:
     world = self.multiworld
-    use_bat_logic = world.bat_logic[self.player].value == BatLogic.option_use_logic
+    use_bat_logic = self.options.bat_logic.value == BatLogic.option_use_logic
 
     set_rule(world.get_entrance("YellowCastlePort", self.player),
              lambda state: state.has("Yellow Key", self.player))
@@ -28,7 +28,7 @@ def set_rules(self) -> None:
                  lambda state: state.has("Bridge", self.player) or
                                state.has("Magnet", self.player))
 
-    dragon_slay_check = world.dragon_slay_check[self.player].value
+    dragon_slay_check = self.options.dragon_slay_check.value
     if dragon_slay_check:
         if self.difficulty_switch_b == DifficultySwitchB.option_hard_with_unlock_item:
             set_rule(world.get_location("Slay Yorgle", self.player),

worlds/adventure/__init__.py

@@ -15,7 +15,8 @@ from Options import AssembleOptions
 from worlds.AutoWorld import WebWorld, World
 from Fill import fill_restrictive
 from worlds.generic.Rules import add_rule, set_rule
-from .Options import adventure_option_definitions, DragonRandoType, DifficultySwitchA, DifficultySwitchB
+from .Options import DragonRandoType, DifficultySwitchA, DifficultySwitchB, \
+    AdventureOptions
 from .Rom import get_base_rom_bytes, get_base_rom_path, AdventureDeltaPatch, apply_basepatch, \
     AdventureAutoCollectLocation
 from .Items import item_table, ItemData, nothing_item_id, event_table, AdventureItem, standard_item_max
@@ -109,7 +110,7 @@ class AdventureWorld(World):
     game: ClassVar[str] = "Adventure"
     web: ClassVar[WebWorld] = AdventureWeb()
 
-    option_definitions: ClassVar[Dict[str, AssembleOptions]] = adventure_option_definitions
+    options_dataclass = AdventureOptions
     settings: ClassVar[AdventureSettings]
     item_name_to_id: ClassVar[Dict[str, int]] = {name: data.id for name, data in item_table.items()}
     location_name_to_id: ClassVar[Dict[str, int]] = {name: data.location_id for name, data in location_table.items()}
@@ -149,18 +150,18 @@ class AdventureWorld(World):
             bytearray(f"ADVENTURE{__version__.replace('.', '')[:3]}_{self.player}_{self.multiworld.seed}", "utf8")[:21]
         self.rom_name.extend([0] * (21 - len(self.rom_name)))
 
-        self.dragon_rando_type = self.multiworld.dragon_rando_type[self.player].value
+        self.dragon_rando_type = self.options.dragon_rando_type.value
-        self.dragon_slay_check = self.multiworld.dragon_slay_check[self.player].value
+        self.dragon_slay_check = self.options.dragon_slay_check.value
-        self.connector_multi_slot = self.multiworld.connector_multi_slot[self.player].value
+        self.connector_multi_slot = self.options.connector_multi_slot.value
-        self.yorgle_speed = self.multiworld.yorgle_speed[self.player].value
+        self.yorgle_speed = self.options.yorgle_speed.value
-        self.yorgle_min_speed = self.multiworld.yorgle_min_speed[self.player].value
+        self.yorgle_min_speed = self.options.yorgle_min_speed.value
-        self.grundle_speed = self.multiworld.grundle_speed[self.player].value
+        self.grundle_speed = self.options.grundle_speed.value
-        self.grundle_min_speed = self.multiworld.grundle_min_speed[self.player].value
+        self.grundle_min_speed = self.options.grundle_min_speed.value
-        self.rhindle_speed = self.multiworld.rhindle_speed[self.player].value
+        self.rhindle_speed = self.options.rhindle_speed.value
-        self.rhindle_min_speed = self.multiworld.rhindle_min_speed[self.player].value
+        self.rhindle_min_speed = self.options.rhindle_min_speed.value
-        self.difficulty_switch_a = self.multiworld.difficulty_switch_a[self.player].value
+        self.difficulty_switch_a = self.options.difficulty_switch_a.value
-        self.difficulty_switch_b = self.multiworld.difficulty_switch_b[self.player].value
+        self.difficulty_switch_b = self.options.difficulty_switch_b.value
-        self.start_castle = self.multiworld.start_castle[self.player].value
+        self.start_castle = self.options.start_castle.value
         self.created_items = 0
 
         if self.dragon_slay_check == 0:
@@ -227,7 +228,7 @@ class AdventureWorld(World):
         extra_filler_count = num_locations - self.created_items
 
         # traps would probably go here, if enabled
-        freeincarnate_max = self.multiworld.freeincarnate_max[self.player].value
+        freeincarnate_max = self.options.freeincarnate_max.value
         actual_freeincarnates = min(extra_filler_count, freeincarnate_max)
         self.multiworld.itempool += [self.create_item("Freeincarnate") for _ in range(actual_freeincarnates)]
         self.created_items += actual_freeincarnates
@@ -247,7 +248,7 @@ class AdventureWorld(World):
                 self.created_items += 1
 
     def create_regions(self) -> None:
-        create_regions(self.multiworld, self.player, self.dragon_rooms)
+        create_regions(self.options, self.multiworld, self.player, self.dragon_rooms)
 
     set_rules = set_rules
 
@@ -354,7 +355,7 @@ class AdventureWorld(World):
         auto_collect_locations: [AdventureAutoCollectLocation] = []
         local_item_to_location: {int, int} = {}
         bat_no_touch_locs: [LocationData] = []
-        bat_logic: int = self.multiworld.bat_logic[self.player].value
+        bat_logic: int = self.options.bat_logic.value
         try:
             rom_deltas: { int, int } = {}
             self.place_dragons(rom_deltas)
@@ -421,7 +422,7 @@ class AdventureWorld(World):
                 item_position_data_start = get_item_position_data_start(unplaced_item.table_index)
                 rom_deltas[item_position_data_start] = 0xff
 
-            if self.multiworld.connector_multi_slot[self.player].value:
+            if self.options.connector_multi_slot.value:
                 rom_deltas[connector_port_offset] = (self.player & 0xff)
             else:
                 rom_deltas[connector_port_offset] = 0

worlds/messenger/options.py

@@ -5,7 +5,7 @@ from schema import And, Optional, Or, Schema
 
 from Options import Accessibility, Choice, DeathLinkMixin, DefaultOnToggle, OptionDict, PerGameCommonOptions, \
     PlandoConnections, Range, StartInventoryPool, Toggle, Visibility
-from worlds.messenger.portals import CHECKPOINTS, PORTALS, SHOP_POINTS
+from .portals import CHECKPOINTS, PORTALS, SHOP_POINTS
 
 
 class MessengerAccessibility(Accessibility):

worlds/mlss/Rom.py

@@ -306,7 +306,6 @@ def write_tokens(world: "MLSSWorld", patch: MLSSProcedurePatch) -> None:
     if world.options.scale_stats:
         patch.write_token(APTokenTypes.WRITE, 0xD00002, bytes([0x1]))
 
-    if world.options.xp_multiplier:
     patch.write_token(APTokenTypes.WRITE, 0xD00003, bytes([world.options.xp_multiplier.value]))
 
     if world.options.tattle_hp:

worlds/sc2/Client.py

@@ -107,10 +107,10 @@ class ColouredMessage:
     def coloured(self, text: str, colour: str) -> 'ColouredMessage':
         add_json_text(self.parts, text, type="color", color=colour)
         return self
-    def location(self, location_id: int, player_id: int = 0) -> 'ColouredMessage':
+    def location(self, location_id: int, player_id: int) -> 'ColouredMessage':
         add_json_location(self.parts, location_id, player_id)
         return self
-    def item(self, item_id: int, player_id: int = 0, flags: int = 0) -> 'ColouredMessage':
+    def item(self, item_id: int, player_id: int, flags: int = 0) -> 'ColouredMessage':
         add_json_item(self.parts, item_id, player_id, flags)
         return self
     def player(self, player_id: int) -> 'ColouredMessage':
@@ -122,7 +122,6 @@ class ColouredMessage:
 
 class StarcraftClientProcessor(ClientCommandProcessor):
     ctx: SC2Context
-    echo_commands = True
 
     def formatted_print(self, text: str) -> None:
         """Prints with kivy formatting to the GUI, and also prints to command-line and to all logs"""
@@ -257,7 +256,7 @@ class StarcraftClientProcessor(ClientCommandProcessor):
                     for item in received_items_of_this_type:
                         print_faction_title()
                         has_printed_faction_title = True
-                        (ColouredMessage('* ').item(item.item, flags=item.flags)
+                        (ColouredMessage('* ').item(item.item, self.ctx.slot, flags=item.flags)
                             (" from ").location(item.location, self.ctx.slot)
                             (" by ").player(item.player)
                         ).send(self.ctx)
@@ -278,7 +277,7 @@ class StarcraftClientProcessor(ClientCommandProcessor):
                         received_items_of_this_type = items_received.get(child_item, [])
                         for item in received_items_of_this_type:
                             filter_match_count += len(received_items_of_this_type)
-                            (ColouredMessage('  * ').item(item.item, flags=item.flags)
+                            (ColouredMessage('  * ').item(item.item, self.ctx.slot, flags=item.flags)
                                 (" from ").location(item.location, self.ctx.slot)
                                 (" by ").player(item.player)
                             ).send(self.ctx)

worlds/shorthike/Rules.py

@@ -1,5 +1,6 @@
 from worlds.generic.Rules import forbid_items_for_player, add_rule
-from worlds.shorthike.Options import Goal, GoldenFeatherProgression, MinShopCheckLogic, ShopCheckLogic
+from .Options import Goal, GoldenFeatherProgression, MinShopCheckLogic, ShopCheckLogic
+
 
 def create_rules(self, location_table):
     multiworld = self.multiworld

worlds/yugioh06/client_bh.py

@@ -5,7 +5,7 @@ from NetUtils import ClientStatus, NetworkItem
 
 import worlds._bizhawk as bizhawk
 from worlds._bizhawk.client import BizHawkClient
-from worlds.yugioh06 import item_to_index
+from . import item_to_index
 
 if TYPE_CHECKING:
     from worlds._bizhawk.context import BizHawkClientContext

worlds/yugioh06/opponents.py

@@ -3,8 +3,8 @@ from typing import Dict, List, NamedTuple, Optional, Union
 from BaseClasses import MultiWorld
 from worlds.generic.Rules import CollectionRule
 
-from worlds.yugioh06 import item_to_index, tier_1_opponents, yugioh06_difficulty
+from . import item_to_index, tier_1_opponents, yugioh06_difficulty
-from worlds.yugioh06.locations import special
+from .locations import special
 
 
 class OpponentData(NamedTuple):