Update VC Redist

MultiMystery is slated to be integrated into Mystery and the auto-launch feature is not maintainable for a growing games list

.gitignore

@@ -12,14 +12,16 @@
 *.db3
 *multidata
 *multisave
+*.archipelago
+*.apsave
 
 build
+/build_factorio/
 bundle/components.wxs
 dist
 README.html
 .vs/
 EnemizerCLI/
-.mypy_cache/
 RaceRom.py
 weights/
 /MultiMystery/
@@ -35,4 +37,110 @@ mystery_result_*.yaml
 success.txt
 output/
 Output Logs/
-/factorio/
+/factorio/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+*.dll
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/

BaseClasses.py

@@ -44,6 +44,7 @@ class MultiWorld():
         self.shops = []
         self.itempool = []
         self.seed = None
+        self.seed_name: str = "Unavailable"
         self.precollected_items = []
         self.state = CollectionState(self)
         self._cached_entrances = None
@@ -68,6 +69,7 @@ class MultiWorld():
         self.fix_palaceofdarkness_exit = self.AttributeProxy(lambda player: self.shuffle[player] not in ['vanilla', 'simple', 'restricted', 'dungeonssimple'])
         self.fix_trock_exit = self.AttributeProxy(lambda player: self.shuffle[player] not in ['vanilla', 'simple', 'restricted', 'dungeonssimple'])
         self.NOTCURSED = self.AttributeProxy(lambda player: not self.CURSED[player])
+        self.remote_items = self.AttributeProxy(lambda player: self.game[player] != "A Link to the Past")
 
         for player in range(1, players + 1):
             def set_player_attr(attr, val):
@@ -87,7 +89,6 @@ class MultiWorld():
             set_player_attr('retro', False)
             set_player_attr('hints', True)
             set_player_attr('player_names', [])
-            set_player_attr('remote_items', False)
             set_player_attr('required_medallions', ['Ether', 'Quake'])
             set_player_attr('swamp_patch_required', False)
             set_player_attr('powder_patch_required', False)
@@ -143,7 +144,9 @@ class MultiWorld():
             import Options
             for hk_option in Options.hollow_knight_options:
                 set_player_attr(hk_option, False)
-
+        self.custom_data = {}
+        for player in range(1, players+1):
+            self.custom_data[player] = {}
         # self.worlds = []
         # for i in range(players):
         #     self.worlds.append(worlds.alttp.ALTTPWorld({}, i))
@@ -167,6 +170,11 @@ class MultiWorld():
     def factorio_player_ids(self):
         yield from (player for player in range(1, self.players + 1) if self.game[player] == "Factorio")
 
+    @property
+    def minecraft_player_ids(self):
+        yield from (player for player in range(1, self.players + 1) if self.game[player] == "Minecraft")
+    
+
     def get_name_string_for_object(self, obj) -> str:
         return obj.name if self.players == 1 else f'{obj.name} ({self.get_player_names(obj.player)})'
 
@@ -231,7 +239,8 @@ class MultiWorld():
         ret = CollectionState(self)
 
         def soft_collect(item):
-            if item.name.startswith('Progressive '):
+            if item.game == "A Link to the Past" and item.name.startswith('Progressive '):
+                # ALttP items
                 if 'Sword' in item.name:
                     if ret.has('Golden Sword', item.player):
                         pass
@@ -321,7 +330,7 @@ class MultiWorld():
         if location.can_fill(self.state, item, False):
             location.item = item
             item.location = location
-            item.world = self # try to not have this here anymore
+            item.world = self  # try to not have this here anymore
             if collect:
                 self.state.collect(item, location.event, location)
 
@@ -403,24 +412,24 @@ class MultiWorld():
             if self.has_beaten_game(self.state):
                 return True
             state = CollectionState(self)
-        prog_locations = {location for location in self.get_locations() if location.item is not None and (
-                    location.item.advancement or location.event) and location not in state.locations_checked}
+        prog_locations = {location for location in self.get_locations() if location.item
+                          and location.item.advancement and location not in state.locations_checked}
 
         while prog_locations:
-            sphere = []
+            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:
                 if location.can_reach(state):
-                    sphere.append(location)
+                    sphere.add(location)
 
             if not sphere:
                 # ran out of places and did not finish yet, quit
                 return False
 
             for location in sphere:
-                prog_locations.remove(location)
                 state.collect(location.item, True, location)
+            prog_locations -= sphere
 
             if self.has_beaten_game(state):
                 return True
@@ -804,6 +813,90 @@ class CollectionState(object):
             rules.append(self.has('Moon Pearl', player))
         return all(rules)
 
+    # Minecraft logic functions
+    def has_iron_ingots(self, player: int):
+        return self.has('Progressive Tools', player) and self.has('Ingot Crafting', player)
+
+    def has_gold_ingots(self, player: int): 
+        return self.has('Ingot Crafting', player) and (self.has('Progressive Tools', player, 2) or self.can_reach('The Nether', 'Region', player))
+
+    def has_diamond_pickaxe(self, player: int):
+        return self.has('Progressive Tools', player, 3) and self.has_iron_ingots(player)
+
+    def craft_crossbow(self, player: int): 
+        return self.has('Archery', player) and self.has_iron_ingots(player)
+
+    def has_bottle_mc(self, player: int): 
+        return self.has('Bottles', player) and self.has('Ingot Crafting', player)
+
+    def can_enchant(self, player: int): 
+        return self.has('Enchanting', player) and self.has_diamond_pickaxe(player) # mine obsidian and lapis
+
+    def can_use_anvil(self, player: int): 
+        return self.has('Enchanting', player) and self.has('Resource Blocks', player) and self.has_iron_ingots(player)
+
+    def fortress_loot(self, player: int): # saddles, blaze rods, wither skulls
+        return self.can_reach('Nether Fortress', 'Region', player) and self.basic_combat(player)
+
+    def can_brew_potions(self, player: int): 
+        return self.fortress_loot(player) and self.has('Brewing', player) and self.has_bottle_mc(player)
+
+    def can_piglin_trade(self, player: int): 
+        return self.has_gold_ingots(player) and (self.can_reach('The Nether', 'Region', player) or self.can_reach('Bastion Remnant', 'Region', player))
+
+    def enter_stronghold(self, player: int): 
+        return self.fortress_loot(player) and self.has('Brewing', player) and self.has('3 Ender Pearls', player)
+
+    # Difficulty-dependent functions
+    def combat_difficulty(self, player: int): 
+        return self.world.combat_difficulty[player].get_option_name()
+
+    def can_adventure(self, player: int):
+        if self.combat_difficulty(player) == 'easy': 
+            return self.has('Progressive Weapons', player, 2) and self.has_iron_ingots(player)
+        elif self.combat_difficulty(player) == 'hard': 
+            return True
+        return self.has('Progressive Weapons', player) and (self.has('Ingot Crafting', player) or self.has('Campfire', player))
+
+    def basic_combat(self, player: int): 
+        if self.combat_difficulty(player) == 'easy': 
+            return self.has('Progressive Weapons', player, 2) and self.has('Progressive Armor', player) and \
+                   self.has('Shield', player) and self.has_iron_ingots(player)
+        elif self.combat_difficulty(player) == 'hard': 
+            return True
+        return self.has('Progressive Weapons', player) and (self.has('Progressive Armor', player) or self.has('Shield', player)) and self.has_iron_ingots(player)
+
+    def complete_raid(self, player: int): 
+        reach_regions = self.can_reach('Village', 'Region', player) and self.can_reach('Pillager Outpost', 'Region', player)
+        if self.combat_difficulty(player) == 'easy': 
+            return reach_regions and \
+                   self.has('Progressive Weapons', player, 3) and self.has('Progressive Armor', player, 2) and \
+                   self.has('Shield', player) and self.has('Archery', player) and \
+                   self.has('Progressive Tools', player, 2) and self.has_iron_ingots(player)
+        elif self.combat_difficulty(player) == 'hard': # might be too hard?
+            return reach_regions and self.has('Progressive Weapons', player, 2) and self.has_iron_ingots(player) and \
+                   (self.has('Progressive Armor', player) or self.has('Shield', player))
+        return reach_regions and self.has('Progressive Weapons', player, 2) and self.has_iron_ingots(player) and \
+               self.has('Progressive Armor', player) and self.has('Shield', player)
+
+    def can_kill_wither(self, player: int): 
+        normal_kill = self.has("Progressive Weapons", player, 3) and self.has("Progressive Armor", player, 2) and self.can_brew_potions(player) and self.can_enchant(player)
+        if self.combat_difficulty(player) == 'easy': 
+            return self.fortress_loot(player) and normal_kill and self.has('Archery', player)
+        elif self.combat_difficulty(player) == 'hard': # cheese kill using bedrock ceilings
+            return self.fortress_loot(player) and (normal_kill or self.can_reach('The Nether', 'Region', player) or self.can_reach('The End', 'Region', player))
+        return self.fortress_loot(player) and normal_kill
+
+    def can_kill_ender_dragon(self, player: int):
+        if self.combat_difficulty(player) == 'easy': 
+            return self.has("Progressive Weapons", player, 3) and self.has("Progressive Armor", player, 2) and self.has('Archery', player) and \
+                   self.can_brew_potions(player) and self.can_enchant(player)
+        if self.combat_difficulty(player) == 'hard': 
+            return (self.has('Progressive Weapons', player, 2) and self.has('Progressive Armor', player)) or \
+                   (self.has('Progressive Weapons', player, 1) and self.has('Bed', player))
+        return self.has('Progressive Weapons', player, 2) and self.has('Progressive Armor', player) and self.has('Archery', player)
+
+
     def collect(self, item: Item, event: bool = False, location: Location = None) -> bool:
         if location:
             self.locations_checked.add(location)
@@ -874,7 +967,7 @@ class CollectionState(object):
     def remove(self, item):
         if item.advancement:
             to_remove = item.name
-            if to_remove.startswith('Progressive '):
+            if item.game == "A Link to the Past" and to_remove.startswith('Progressive '):
                 if 'Sword' in to_remove:
                     if self.has('Golden Sword', item.player):
                         to_remove = 'Golden Sword'
@@ -901,7 +994,7 @@ class CollectionState(object):
                     elif self.has('Blue Shield', item.player):
                         to_remove = 'Blue Shield'
                     else:
-                        to_remove = 'None'
+                        to_remove = None
                 elif 'Bow' in item.name:
                     if self.has('Silver Bow', item.player):
                         to_remove = 'Silver Bow'
@@ -910,7 +1003,7 @@ class CollectionState(object):
                     else:
                         to_remove = None
 
-            if to_remove is not None:
+            if to_remove:
 
                 self.prog_items[to_remove, item.player] -= 1
                 if self.prog_items[to_remove, item.player] < 1:
@@ -1100,6 +1193,14 @@ class Location():
             return True
         return False
 
+    def place_locked_item(self, item: Item):
+        if self.item:
+            raise Exception(f"Location {self} already filled.")
+        self.item = item
+        self.event = item.advancement
+        self.item.world = self.parent_region.world
+        self.locked = True
+
     def __repr__(self):
         return self.__str__()
 
@@ -1128,7 +1229,7 @@ class Item():
     zora_credit_text = None
     fluteboy_credit_text = None
 
-    def __init__(self, name: str, advancement: bool, code: int, player: int):
+    def __init__(self, name: str, advancement: bool, code: Optional[int], player: int):
         self.name = name
         self.advancement = advancement
         self.player = player
@@ -1374,6 +1475,7 @@ class Spoiler(object):
         return json.dumps(out)
 
     def to_file(self, filename):
+        import Options
         self.parse_data()
 
         def bool_to_text(variable: Union[bool, str]) -> str:
@@ -1397,11 +1499,21 @@ class Spoiler(object):
                         'Yes' if self.metadata['progression_balancing'][player] else 'No'))
                 outfile.write('Accessibility:                   %s\n' % self.metadata['accessibility'][player])
                 if player in self.world.hk_player_ids:
-                    import Options
                     for hk_option in Options.hollow_knight_options:
                         res = getattr(self.world, hk_option)[player]
                         outfile.write(f'{hk_option+":":33}{res}\n')
-                if player in self.world.alttp_player_ids:
+
+                elif player in self.world.factorio_player_ids:
+                    for f_option in Options.factorio_options:
+                        res = getattr(self.world, f_option)[player]
+                        outfile.write(f'{f_option+":":33}{bool_to_text(res) if type(res) == Options.Toggle else res.get_option_name()}\n')
+
+                elif player in self.world.minecraft_player_ids:
+                    for mc_option in Options.minecraft_options:
+                        res = getattr(self.world, mc_option)[player]
+                        outfile.write(f'{mc_option+":":33}{bool_to_text(res) if type(res) == Options.Toggle else res.get_option_name()}\n')
+
+                elif player in self.world.alttp_player_ids:
                     for team in range(self.world.teams):
                         outfile.write('%s%s\n' % (
                             f"Hash - {self.world.player_names[player][team]} (Team {team + 1}): " if
@@ -1416,7 +1528,7 @@ class Spoiler(object):
                     outfile.write('Mode:                            %s\n' % self.metadata['mode'][player])
                     outfile.write('Retro:                           %s\n' %
                                   ('Yes' if self.metadata['retro'][player] else 'No'))
-                    outfile.write('Swordless:                          %s\n' % ('Yes' if self.metadata['swordless'][player] else 'No'))
+                    outfile.write('Swordless:                       %s\n' % ('Yes' if self.metadata['swordless'][player] else 'No'))
                     outfile.write('Goal:                            %s\n' % self.metadata['goal'][player])
                     if "triforce" in self.metadata["goal"][player]:  # triforce hunt
                         outfile.write("Pieces available for Triforce:   %s\n" %
@@ -1477,17 +1589,24 @@ class Spoiler(object):
                                                          '<=>' if entry['direction'] == 'both' else
                                                          '<=' if entry['direction'] == 'exit' else '=>',
                                                          entry['exit']) for entry in self.entrances.values()]))
-            outfile.write('\n\nMedallions:\n')
-            for dungeon, medallion in self.medallions.items():
-                outfile.write(f'\n{dungeon}: {medallion}')
+
+            if self.medallions:
+                outfile.write('\n\nMedallions:\n')
+                for dungeon, medallion in self.medallions.items():
+                    outfile.write(f'\n{dungeon}: {medallion}')
+
             if self.startinventory:
                 outfile.write('\n\nStarting Inventory:\n\n')
                 outfile.write('\n'.join(self.startinventory))
+
             outfile.write('\n\nLocations:\n\n')
             outfile.write('\n'.join(['%s: %s' % (location, item) for grouping in self.locations.values() for (location, item) in grouping.items()]))
-            outfile.write('\n\nShops:\n\n')
-            outfile.write('\n'.join("{} [{}]\n    {}".format(shop['location'], shop['type'], "\n    ".join(item for item in [shop.get('item_0', None), shop.get('item_1', None), shop.get('item_2', None)] if item)) for shop in self.shops))
-            for player in range(1, self.world.players + 1):
+
+            if self.shops:
+                outfile.write('\n\nShops:\n\n')
+                outfile.write('\n'.join("{} [{}]\n    {}".format(shop['location'], shop['type'], "\n    ".join(item for item in [shop.get('item_0', None), shop.get('item_1', None), shop.get('item_2', None)] if item)) for shop in self.shops))
+
+            for player in self.world.alttp_player_ids:
                 if self.world.boss_shuffle[player] != 'none':
                     bossmap = self.bosses[str(player)] if self.world.players > 1 else self.bosses
                     outfile.write(f'\n\nBosses{(f" ({self.world.get_player_names(player)})" if self.world.players > 1 else "")}:\n')
@@ -1497,19 +1616,20 @@ class Spoiler(object):
             if self.unreachables:
                 outfile.write('\n\nUnreachable Items:\n\n')
                 outfile.write('\n'.join(['%s: %s' % (unreachable.item, unreachable) for unreachable in self.unreachables]))
-            outfile.write('\n\nPaths:\n\n')
 
-            path_listings = []
-            for location, path in sorted(self.paths.items()):
-                path_lines = []
-                for region, exit in path:
-                    if exit is not None:
-                        path_lines.append("{} -> {}".format(region, exit))
-                    else:
-                        path_lines.append(region)
-                path_listings.append("{}\n        {}".format(location, "\n   =>   ".join(path_lines)))
+            if self.paths:
+                outfile.write('\n\nPaths:\n\n')
+                path_listings = []
+                for location, path in sorted(self.paths.items()):
+                    path_lines = []
+                    for region, exit in path:
+                        if exit is not None:
+                            path_lines.append("{} -> {}".format(region, exit))
+                        else:
+                            path_lines.append(region)
+                    path_listings.append("{}\n        {}".format(location, "\n   =>   ".join(path_lines)))
 
-            outfile.write('\n'.join(path_listings))
+                outfile.write('\n'.join(path_listings))
 
 from worlds.alttp.Items import item_name_groups
 from worlds.generic import PlandoItem, PlandoConnection

CommonClient.py

@@ -49,10 +49,6 @@ class ClientCommandProcessor(CommandProcessor):
         """List all received items"""
         logger.info('Received items:')
         for index, item in enumerate(self.ctx.items_received, 1):
-            self.ctx.ui_node.notify_item_received(self.ctx.player_names[item.player], self.ctx.item_name_getter(item.item),
-                                                  self.ctx.location_name_getter(item.location), index,
-                                                  len(self.ctx.items_received),
-                                                  self.ctx.item_name_getter(item.item) in Items.progression_items)
             logging.info('%s from %s (%s) (%d/%d in list)' % (
                 color(self.ctx.item_name_getter(item.item), 'red', 'bold'),
                 color(self.ctx.player_names[item.player], 'yellow'),
@@ -116,7 +112,7 @@ class CommonContext():
         self.team = None
         self.slot = None
         self.auth = None
-        self.ui_node = None
+        self.seed_name = None
 
         self.locations_checked: typing.Set[int] = set()
         self.locations_scouted: typing.Set[int] = set()
@@ -129,7 +125,7 @@ class CommonContext():
         self.input_requests = 0
 
         # game state
-        self.player_names: typing.Dict[int: str] = {}
+        self.player_names: typing.Dict[int: str] = {0: "Archipelago"}
         self.exit_event = asyncio.Event()
         self.watcher_event = asyncio.Event()
 
@@ -184,7 +180,6 @@ class CommonContext():
     async def disconnect(self):
         if self.server and not self.server.socket.closed:
             await self.server.socket.close()
-            self.ui_node.send_connection_status(self)
         if self.server_task is not None:
             await self.server_task
 
@@ -195,6 +190,7 @@ class CommonContext():
 
     def consume_players_package(self, package: typing.List[tuple]):
         self.player_names = {slot: name for team, slot, name, orig_name in package if self.team == team}
+        self.player_names[0] = "Archipelago"
 
     def event_invalid_slot(self):
         raise Exception('Invalid Slot; please verify that you have connected to the correct world.')
@@ -213,11 +209,16 @@ class CommonContext():
         await self.disconnect()
         self.server_task = asyncio.create_task(server_loop(self, address))
 
+    def on_print(self, args: dict):
+        logger.info(args["text"])
+
+    def on_print_json(self, args: dict):
+        if not self.found_items and args.get("type", None) == "ItemSend" and args["receiving"] == args["sending"]:
+            pass  # don't want info on other player's local pickups.
+        logger.info(self.jsontotextparser(args["data"]))
+
 
 async def server_loop(ctx: CommonContext, address=None):
-    ui_node = getattr(ctx, "ui_node", None)
-    if ui_node:
-        ui_node.send_connection_status(ctx)
     cached_address = None
     if ctx.server and ctx.server.socket:
         logger.error('Already connected')
@@ -229,8 +230,6 @@ async def server_loop(ctx: CommonContext, address=None):
     # Wait for the user to provide a multiworld server address
     if not address:
         logger.info('Please connect to an Archipelago server.')
-        if ui_node:
-            ui_node.poll_for_server_ip()
         return
 
     address = f"ws://{address}" if "://" not in address else address
@@ -242,8 +241,6 @@ async def server_loop(ctx: CommonContext, address=None):
         ctx.server = Endpoint(socket)
         logger.info('Connected')
         ctx.server_address = address
-        if ui_node:
-            ui_node.send_connection_status(ctx)
         ctx.current_reconnect_delay = ctx.starting_reconnect_delay
         async for data in ctx.server.socket:
             for msg in decode(data):
@@ -265,8 +262,6 @@ async def server_loop(ctx: CommonContext, address=None):
         await ctx.connection_closed()
         if ctx.server_address:
             logger.info(f"... reconnecting in {ctx.current_reconnect_delay}s")
-            if ui_node:
-                ui_node.send_connection_status(ctx)
             asyncio.create_task(server_autoreconnect(ctx))
         ctx.current_reconnect_delay *= 2
 
@@ -284,41 +279,42 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
         logger.exception(f"Could not get command from {args}")
         raise
     if cmd == 'RoomInfo':
-        logger.info('--------------------------------')
-        logger.info('Room Information:')
-        logger.info('--------------------------------')
-        version = args["version"]
-        ctx.server_version = tuple(version)
-        version = ".".join(str(item) for item in version)
-
-        logger.info(f'Server protocol version: {version}')
-        logger.info("Server protocol tags: " + ", ".join(args["tags"]))
-        if args['password']:
-            logger.info('Password required')
-        logger.info(f"Forfeit setting: {args['forfeit_mode']}")
-        logger.info(f"Remaining setting: {args['remaining_mode']}")
-        logger.info(f"A !hint costs {args['hint_cost']} points and you get {args['location_check_points']}"
-                     f" for each location checked.")
-        ctx.hint_cost = int(args['hint_cost'])
-        ctx.check_points = int(args['location_check_points'])
-        ctx.forfeit_mode = args['forfeit_mode']
-        ctx.remaining_mode = args['remaining_mode']
-        if ctx.ui_node:
-            ctx.ui_node.send_game_info(ctx)
-        if len(args['players']) < 1:
-            logger.info('No player connected')
+        if ctx.seed_name and ctx.seed_name != args["seed_name"]:
+            logger.info("The server is running a different multiworld than your client is. (invalid seed_name)")
         else:
-            args['players'].sort()
-            current_team = -1
-            logger.info('Players:')
-            for network_player in args['players']:
-                if network_player.team != current_team:
-                    logger.info(f'  Team #{network_player.team + 1}')
-                    current_team = network_player.team
-                logger.info('    %s (Player %d)' % (network_player.alias, network_player.slot))
-        if args["datapackage_version"] > network_data_package["version"] or args["datapackage_version"] == 0:
-            await ctx.send_msgs([{"cmd": "GetDataPackage"}])
-        await ctx.server_auth(args['password'])
+            logger.info('--------------------------------')
+            logger.info('Room Information:')
+            logger.info('--------------------------------')
+            version = args["version"]
+            ctx.server_version = tuple(version)
+            version = ".".join(str(item) for item in version)
+
+            logger.info(f'Server protocol version: {version}')
+            logger.info("Server protocol tags: " + ", ".join(args["tags"]))
+            if args['password']:
+                logger.info('Password required')
+            logger.info(f"Forfeit setting: {args['forfeit_mode']}")
+            logger.info(f"Remaining setting: {args['remaining_mode']}")
+            logger.info(f"A !hint costs {args['hint_cost']}% of checks points and you get {args['location_check_points']}"
+                         f" for each location checked. Use !hint for more information.")
+            ctx.hint_cost = int(args['hint_cost'])
+            ctx.check_points = int(args['location_check_points'])
+            ctx.forfeit_mode = args['forfeit_mode']
+            ctx.remaining_mode = args['remaining_mode']
+            if len(args['players']) < 1:
+                logger.info('No player connected')
+            else:
+                args['players'].sort()
+                current_team = -1
+                logger.info('Players:')
+                for network_player in args['players']:
+                    if network_player.team != current_team:
+                        logger.info(f'  Team #{network_player.team + 1}')
+                        current_team = network_player.team
+                    logger.info('    %s (Player %d)' % (network_player.alias, network_player.slot))
+            if args["datapackage_version"] > network_data_package["version"] or args["datapackage_version"] == 0:
+                await ctx.send_msgs([{"cmd": "GetDataPackage"}])
+            await ctx.server_auth(args['password'])
 
     elif cmd == 'DataPackage':
         logger.info("Got new ID/Name Datapackage")
@@ -394,12 +390,10 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
             ctx.hint_points = args['hint_points']
 
     elif cmd == 'Print':
-        logger.info(args["text"])
+        ctx.on_print(args)
 
     elif cmd == 'PrintJSON':
-        if not ctx.found_items and args.get("type", None) == "ItemSend" and args["receiving"] == args["sending"]:
-            pass  # don't want info on other player's local pickups.
-        logger.info(ctx.jsontotextparser(args["data"]))
+        ctx.on_print_json(args)
 
     elif cmd == 'InvalidArguments':
         logger.warning(f"Invalid Arguments: {args['text']}")

FactorioClient.py

@@ -1,17 +1,21 @@
+from __future__ import annotations
 import os
 import logging
 import json
 import string
+import copy
+import sys
 from concurrent.futures import ThreadPoolExecutor
 
 import colorama
 import asyncio
-from queue import Queue, Empty
-from CommonClient import CommonContext, server_loop, console_loop, ClientCommandProcessor
+from queue import Queue
+from CommonClient import CommonContext, server_loop, console_loop, ClientCommandProcessor, logger
 from MultiServer import mark_raw
 
 import Utils
 import random
+from NetUtils import RawJSONtoTextParser, NetworkItem, ClientStatus, JSONtoTextParser, JSONMessagePart
 
 from worlds.factorio.Technologies import lookup_id_to_name
 
@@ -19,8 +23,6 @@ rcon_port = 24242
 rcon_password = ''.join(random.choice(string.ascii_letters) for x in range(32))
 save_name = "Archipelago"
 
-server_args = (save_name, "--rcon-port", rcon_port, "--rcon-password", rcon_password)
-
 logging.basicConfig(format='[%(name)s]: %(message)s', level=logging.INFO)
 options = Utils.get_options()
 executable = options["factorio_options"]["executable"]
@@ -33,11 +35,14 @@ if not os.path.exists(executable):
     else:
         raise FileNotFoundError(executable)
 
-script_folder = options["factorio_options"]["script-output"]
+server_args = (save_name, "--rcon-port", rcon_port, "--rcon-password", rcon_password, *sys.argv[1:])
+
+thread_pool = ThreadPoolExecutor(10)
 
-threadpool = ThreadPoolExecutor(10)
 
 class FactorioCommandProcessor(ClientCommandProcessor):
+    ctx: FactorioContext
+
     @mark_raw
     def _cmd_factorio(self, text: str) -> bool:
         """Send the following command to the bound Factorio Server."""
@@ -48,9 +53,10 @@ class FactorioCommandProcessor(ClientCommandProcessor):
             return True
         return False
 
-    def _cmd_connect(self, address: str = "", name="") -> bool:
+    def _cmd_connect(self, address: str = "") -> bool:
         """Connect to a MultiWorld Server"""
-        self.ctx.auth = name
+        if not self.ctx.auth:
+            self.output("Cannot connect to a server with unknown own identity, bridge to Factorio first.")
         return super(FactorioCommandProcessor, self)._cmd_connect(address)
 
 
@@ -61,13 +67,13 @@ class FactorioContext(CommonContext):
         super(FactorioContext, self).__init__(*args, **kwargs)
         self.send_index = 0
         self.rcon_client = None
+        self.awaiting_bridge = False
+        self.raw_json_text_parser = RawJSONtoTextParser(self)
+        self.factorio_json_text_parser = FactorioJSONtoTextParser(self)
 
     async def server_auth(self, password_requested):
         if password_requested and not self.password:
             await super(FactorioContext, self).server_auth(password_requested)
-        if self.auth is None:
-            logging.info('Enter the name of your slot to join this game:')
-            self.auth = await self.console_input()
 
         await self.send_msgs([{"cmd": 'Connect',
                                'password': self.password, 'name': self.auth, 'version': Utils._version_tuple,
@@ -75,38 +81,69 @@ class FactorioContext(CommonContext):
                                'uuid': Utils.get_unique_identifier(), 'game': "Factorio"
                                }])
 
+    def on_print(self, args: dict):
+        logger.info(args["text"])
+        if self.rcon_client:
+            cleaned_text = args['text'].replace('"', '')
+            self.rcon_client.send_command(f"/sc game.print(\"[font=default-large-bold]Archipelago:[/font] "
+                                          f"{cleaned_text}\")")
 
-async def game_watcher(ctx: FactorioContext):
-    research_logger = logging.getLogger("FactorioWatcher")
-    researches_done_file = os.path.join(script_folder, "research_done.json")
-    if os.path.exists(researches_done_file):
-        os.remove(researches_done_file)
+    def on_print_json(self, args: dict):
+        if not self.found_items and args.get("type", None) == "ItemSend" and args["receiving"] == args["sending"]:
+            pass  # don't want info on other player's local pickups.
+        text = self.raw_json_text_parser(copy.deepcopy(args["data"]))
+        logger.info(text)
+        if self.rcon_client:
+            text = self.factorio_json_text_parser(args["data"])
+            cleaned_text = text.replace('"', '')
+            self.rcon_client.send_command(f"/sc game.print(\"[font=default-large-bold]Archipelago:[/font] "
+                                          f"{cleaned_text}\")")
+
+
+async def game_watcher(ctx: FactorioContext, bridge_file: str):
+    bridge_logger = logging.getLogger("FactorioWatcher")
     from worlds.factorio.Technologies import lookup_id_to_name
     bridge_counter = 0
     try:
-        while 1:
-            if os.path.exists(researches_done_file):
-                research_logger.info("Found Factorio Bridge file.")
-                while 1:
-                    with open(researches_done_file) as f:
-                        data = json.load(f)
-                        research_data = {int(tech_name.split("-")[1]) for tech_name in data if tech_name.startswith("ap-")}
-                    if ctx.locations_checked != research_data:
-                        research_logger.info(f"New researches done: "
-                                             f"{[lookup_id_to_name[rid] for rid in research_data - ctx.locations_checked]}")
-                        ctx.locations_checked = research_data
-                        await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": tuple(research_data)}])
+        while not ctx.exit_event.is_set():
+            if os.path.exists(bridge_file):
+                bridge_logger.info("Found Factorio Bridge file.")
+                while not ctx.exit_event.is_set():
+                    if ctx.awaiting_bridge:
+                        ctx.awaiting_bridge = False
+                        with open(bridge_file) as f:
+                            data = json.load(f)
+                            research_data = data["research_done"]
+                            research_data = {int(tech_name.split("-")[1]) for tech_name in research_data}
+                            victory = data["victory"]
+                            ctx.auth = data["slot_name"]
+                            ctx.seed_name = data["seed_name"]
+
+                        if not ctx.finished_game and victory:
+                            await ctx.send_msgs([{"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}])
+                            ctx.finished_game = True
+
+                        if ctx.locations_checked != research_data:
+                            bridge_logger.info(
+                                f"New researches done: "
+                                f"{[lookup_id_to_name[rid] for rid in research_data - ctx.locations_checked]}")
+                            ctx.locations_checked = research_data
+                            await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": tuple(research_data)}])
                     await asyncio.sleep(1)
             else:
                 bridge_counter += 1
                 if bridge_counter >= 60:
-                    research_logger.info("Did not find Factorio Bridge file, waiting for mod to run.")
-                    bridge_counter = 1
+                    bridge_logger.info(
+                        "Did not find Factorio Bridge file, "
+                        "waiting for mod to run, which requires the server to run, "
+                        "which requires a player to be connected.")
+                    bridge_counter = 0
                 await asyncio.sleep(1)
     except Exception as e:
         logging.exception(e)
         logging.error("Aborted Factorio Server Bridge")
 
+
 def stream_factorio_output(pipe, queue):
     def queuer():
         while 1:
@@ -133,32 +170,52 @@ async def factorio_server_watcher(ctx: FactorioContext):
     factorio_queue = Queue()
     stream_factorio_output(factorio_process.stdout, factorio_queue)
     stream_factorio_output(factorio_process.stderr, factorio_queue)
+    script_folder = None
+    progression_watcher = None
     try:
-        while 1:
+        while not ctx.exit_event.is_set():
             while not factorio_queue.empty():
                 msg = factorio_queue.get()
                 factorio_server_logger.info(msg)
-                if not ctx.rcon_client and "Hosting game at IP ADDR:" in msg:
+                if not ctx.rcon_client and "Starting RCON interface at IP ADDR:" in msg:
                     ctx.rcon_client = factorio_rcon.RCONClient("localhost", rcon_port, rcon_password)
                     # trigger lua interface confirmation
                     ctx.rcon_client.send_command("/sc game.print('Starting Archipelago Bridge')")
                     ctx.rcon_client.send_command("/sc game.print('Starting Archipelago Bridge')")
+                    ctx.rcon_client.send_command("/ap-sync")
+                if not script_folder and "Write data path:" in msg:
+                    script_folder = msg.split("Write data path: ", 1)[1].split("[", 1)[0].strip()
+                    bridge_file = os.path.join(script_folder, "script-output", "ap_bridge.json")
+                    if os.path.exists(bridge_file):
+                        os.remove(bridge_file)
+                    logging.info(f"Bridge File Path: {bridge_file}")
+                    progression_watcher = asyncio.create_task(
+                        game_watcher(ctx, bridge_file), name="FactorioProgressionWatcher")
+                if not ctx.awaiting_bridge and "Archipelago Bridge File written for game tick " in msg:
+                    ctx.awaiting_bridge = True
             if ctx.rcon_client:
                 while ctx.send_index < len(ctx.items_received):
-                    item_id = ctx.items_received[ctx.send_index].item
+                    transfer_item: NetworkItem = ctx.items_received[ctx.send_index]
+                    item_id = transfer_item.item
+                    player_name = ctx.player_names[transfer_item.player]
                     if item_id not in lookup_id_to_name:
                         logging.error(f"Cannot send unknown item ID: {item_id}")
                     else:
                         item_name = lookup_id_to_name[item_id]
-                        factorio_server_logger.info(f"Sending {item_name} to Nauvis.")
-                        ctx.rcon_client.send_command(f'/ap-get-technology {item_name}')
+                        factorio_server_logger.info(f"Sending {item_name} to Nauvis from {player_name}.")
+                        ctx.rcon_client.send_command(f'/ap-get-technology {item_name} {player_name}')
                     ctx.send_index += 1
-
             await asyncio.sleep(1)
+
     except Exception as e:
         logging.exception(e)
         logging.error("Aborted Factorio Server Bridge")
 
+    finally:
+        factorio_process.terminate()
+        if progression_watcher:
+            await progression_watcher
+
 
 async def main():
     ctx = FactorioContext(None, None, True)
@@ -168,14 +225,13 @@ async def main():
     if ctx.server_task is None:
         ctx.server_task = asyncio.create_task(server_loop(ctx), name="ServerLoop")
     await asyncio.sleep(3)
-    watcher_task = asyncio.create_task(game_watcher(ctx), name="FactorioProgressionWatcher")
     input_task = asyncio.create_task(console_loop(ctx), name="Input")
     factorio_server_task = asyncio.create_task(factorio_server_watcher(ctx), name="FactorioServer")
     await ctx.exit_event.wait()
     ctx.server_address = None
     ctx.snes_reconnect_address = None
 
-    await asyncio.gather(watcher_task, input_task, factorio_server_task)
+    await asyncio.gather(input_task, factorio_server_task)
 
     if ctx.server is not None and not ctx.server.socket.closed:
         await ctx.server.socket.close()
@@ -190,6 +246,20 @@ async def main():
     await input_task
 
 
+class FactorioJSONtoTextParser(JSONtoTextParser):
+    def _handle_color(self, node: JSONMessagePart):
+        colors = node["color"].split(";")
+        for color in colors:
+            if color in {"red", "green", "blue", "orange", "yellow", "pink", "purple", "white", "black", "gray",
+                         "brown", "cyan", "acid"}:
+                node["text"] = f"[color={color}]{node['text']}[/color]"
+                return self._handle_text(node)
+            elif color == "magenta":
+                node["text"] = f"[color=pink]{node['text']}[/color]"
+            return self._handle_text(node)
+        return self._handle_text(node)
+
+
 if __name__ == '__main__':
     colorama.init()
     loop = asyncio.get_event_loop()

FactorioClientGUI.py

@@ -0,0 +1,167 @@
+import os
+import logging
+import sys
+os.makedirs("logs", exist_ok=True)
+if getattr(sys, "frozen", False):
+    logging.basicConfig(format='[%(name)s]: %(message)s', level=logging.INFO,
+                        filename=os.path.join("logs", "FactorioClient.txt"), filemode="w")
+else:
+    logging.basicConfig(format='[%(name)s]: %(message)s', level=logging.INFO)
+    logging.getLogger().addHandler(logging.FileHandler(os.path.join("logs", "FactorioClient.txt"), "w"))
+os.environ["KIVY_NO_CONSOLELOG"] = "1"
+os.environ["KIVY_NO_FILELOG"] = "1"
+os.environ["KIVY_NO_ARGS"] = "1"
+
+import asyncio
+from CommonClient import server_loop, logger
+from FactorioClient import FactorioContext, factorio_server_watcher
+
+
+async def main():
+    ctx = FactorioContext(None, None, True)
+
+    ctx.server_task = asyncio.create_task(server_loop(ctx), name="ServerLoop")
+    factorio_server_task = asyncio.create_task(factorio_server_watcher(ctx), name="FactorioServer")
+    ui_app = FactorioManager(ctx)
+    ui_task = asyncio.create_task(ui_app.async_run(), name="UI")
+
+    await ctx.exit_event.wait()  # wait for signal to exit application
+    ui_app.stop()
+    ctx.server_address = None
+    ctx.snes_reconnect_address = None
+    # allow tasks to quit
+    await ui_task
+    await factorio_server_task
+    await ctx.server_task
+
+    if ctx.server is not None and not ctx.server.socket.closed:
+        await ctx.server.socket.close()
+    if ctx.server_task is not None:
+        await ctx.server_task
+
+    while ctx.input_requests > 0:  # clear queue for shutdown
+        ctx.input_queue.put_nowait(None)
+        ctx.input_requests -= 1
+
+
+from kivy.app import App
+from kivy.uix.label import Label
+from kivy.base import ExceptionHandler, ExceptionManager, Config
+from kivy.uix.gridlayout import GridLayout
+from kivy.uix.textinput import TextInput
+from kivy.uix.recycleview import RecycleView
+from kivy.uix.tabbedpanel import TabbedPanel, TabbedPanelItem
+from kivy.lang import Builder
+
+
+class FactorioManager(App):
+    def __init__(self, ctx):
+        super(FactorioManager, self).__init__()
+        self.ctx = ctx
+        self.commandprocessor = ctx.command_processor(ctx)
+        self.icon = "data/icon.png"
+
+    def build(self):
+        self.grid = GridLayout()
+        self.grid.cols = 1
+        self.tabs = TabbedPanel()
+        self.tabs.default_tab_text = "All"
+        self.title = "Archipelago Factorio Client"
+        pairs = [
+            ("Client", "Archipelago"),
+            ("FactorioServer", "Factorio Server Log"),
+            ("FactorioWatcher", "Bridge File Log"),
+        ]
+        self.tabs.default_tab_content = UILog(*(logging.getLogger(logger_name) for logger_name, name in pairs))
+        for logger_name, display_name in pairs:
+            bridge_logger = logging.getLogger(logger_name)
+            panel = TabbedPanelItem(text=display_name)
+            panel.content = UILog(bridge_logger)
+            self.tabs.add_widget(panel)
+
+        self.grid.add_widget(self.tabs)
+        textinput = TextInput(size_hint_y=None, height=30, multiline=False)
+        textinput.bind(on_text_validate=self.on_message)
+        self.grid.add_widget(textinput)
+        self.commandprocessor("/help")
+        return self.grid
+
+    def on_stop(self):
+        self.ctx.exit_event.set()
+
+    def on_message(self, textinput: TextInput):
+        try:
+            input_text = textinput.text.strip()
+            textinput.text = ""
+
+            if self.ctx.input_requests > 0:
+                self.ctx.input_requests -= 1
+                self.ctx.input_queue.put_nowait(input_text)
+            elif input_text:
+                self.commandprocessor(input_text)
+        except Exception as e:
+            logger.exception(e)
+
+
+class LogtoUI(logging.Handler):
+    def __init__(self, on_log):
+        super(LogtoUI, self).__init__(logging.DEBUG)
+        self.on_log = on_log
+
+    def handle(self, record: logging.LogRecord) -> None:
+        self.on_log(record)
+
+
+class UILog(RecycleView):
+    cols = 1
+
+    def __init__(self, *loggers_to_handle, **kwargs):
+        super(UILog, self).__init__(**kwargs)
+        self.data = []
+        for logger in loggers_to_handle:
+            logger.addHandler(LogtoUI(self.on_log))
+
+    def on_log(self, record: logging.LogRecord) -> None:
+        self.data.append({"text": record.getMessage()})
+
+
+class E(ExceptionHandler):
+    def handle_exception(self, inst):
+        logger.exception(inst)
+        return ExceptionManager.RAISE
+
+ExceptionManager.add_handler(E())
+
+
+Config.set("input", "mouse", "mouse,disable_multitouch")
+Builder.load_string('''
+<TabbedPanel>
+    tab_width: 200
+<Row@Label>:
+    canvas.before:
+        Color:
+            rgba: 0.2, 0.2, 0.2, 1
+        Rectangle:
+            size: self.size
+            pos: self.pos
+    text_size: self.width, None
+    size_hint_y: None
+    height: self.texture_size[1]
+    font_size: dp(20)
+<UILog>:
+    viewclass: 'Row'
+    scroll_y: 0
+    effect_cls: "ScrollEffect"
+    RecycleBoxLayout:
+        default_size: None, dp(20)
+        default_size_hint: 1, None
+        size_hint_y: None
+        height: self.minimum_height
+        orientation: 'vertical'
+        spacing: dp(3)
+''')
+
+if __name__ == '__main__':
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(main())
+    loop.close()

Gui.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+# module is planned to be removed
 from argparse import Namespace
 from glob import glob
 import json
@@ -427,7 +428,6 @@ def guiMain(args=None):
         guiargs.fastmenu = rom_vars.fastMenuVar.get()
         guiargs.create_spoiler = bool(createSpoilerVar.get())
         guiargs.skip_playthrough = not bool(createSpoilerVar.get())
-        guiargs.suppress_rom = bool(suppressRomVar.get())
         guiargs.open_pyramid = openpyramidVar.get()
         guiargs.mapshuffle = bool(mapshuffleVar.get())
         guiargs.compassshuffle = bool(compassshuffleVar.get())
@@ -512,7 +512,7 @@ def guiMain(args=None):
             elif type(v) is dict: # use same settings for every player
                 setattr(guiargs, k, {player: getattr(guiargs, k) for player in range(1, guiargs.multi + 1)})
         try:
-            if not guiargs.suppress_rom and not os.path.exists(guiargs.rom):
+            if not os.path.exists(guiargs.rom):
                 raise FileNotFoundError(f"Could not find specified rom file {guiargs.rom}")
             if guiargs.count is not None:
                 seed = guiargs.seed
@@ -1203,7 +1203,6 @@ def guiMain(args=None):
                 setattr(args, k, v[1]) # only get values for player 1 for now
         # load values from commandline args
         createSpoilerVar.set(int(args.create_spoiler))
-        suppressRomVar.set(int(args.suppress_rom))
         mapshuffleVar.set(args.mapshuffle)
         compassshuffleVar.set(args.compassshuffle)
         keyshuffleVar.set(args.keyshuffle)
@@ -1745,7 +1744,8 @@ def update_sprites(task, on_finish=None):
     try:
         task.update_status("Determining needed sprites")
         current_sprites = [os.path.basename(file) for file in glob(sprite_dir + '/*')]
-        alttpr_sprites = [(sprite['file'], os.path.basename(urlparse(sprite['file']).path)) for sprite in sprites_arr]
+        alttpr_sprites = [(sprite['file'], os.path.basename(urlparse(sprite['file']).path))
+                          for sprite in sprites_arr if sprite["author"] != "Nintendo"]
         needed_sprites = [(sprite_url, filename) for (sprite_url, filename) in alttpr_sprites if filename not in current_sprites]
 
         alttpr_filenames = [filename for (_, filename) in alttpr_sprites]
@@ -1909,6 +1909,7 @@ def get_image_for_sprite(sprite, gif_only: bool = False):
 
     return image.zoom(2)
 
+
 if __name__ == '__main__':
     import sys
     if "update_sprites" in sys.argv:

GuiUtils.py

@@ -5,10 +5,8 @@ import tkinter as tk
 from Utils import local_path
 
 def set_icon(window):
-    er16 = tk.PhotoImage(file=local_path('data', 'ER16.gif'))
-    er32 = tk.PhotoImage(file=local_path('data', 'ER32.gif'))
-    er48 = tk.PhotoImage(file=local_path('data', 'ER32.gif'))
-    window.tk.call('wm', 'iconphoto', window._w, er16, er32, er48)  # pylint: disable=protected-access
+    logo = tk.PhotoImage(file=local_path('data', 'icon.png'))
+    window.tk.call('wm', 'iconphoto', window._w, logo)
 
 # Although tkinter is intended to be thread safe, there are many reports of issues
 # some which may be platform specific, or depend on if the TCL library was compiled without

LICENSE

@@ -3,7 +3,7 @@ MIT License
 Copyright (c) 2017 LLCoolDave
 Copyright (c) 2021 Berserker66
 Copyright (c) 2021 CaitSith2
-Copyright (c) 2020 LegendaryLinux
+Copyright (c) 2021 LegendaryLinux
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

LttPAdjuster.py

@@ -5,6 +5,10 @@ import logging
 import textwrap
 import sys
 import time
+from tkinter import Tk
+
+from Gui import update_sprites
+from GuiUtils import BackgroundTaskProgress
 
 from worlds.alttp.Rom import Sprite, LocalRom, apply_rom_settings
 from Utils import output_path
@@ -16,46 +20,67 @@ class AdjusterWorld(object):
         self.sprite_pool = {1: sprite_pool}
         self.rom_seeds = {1: random}
 
+
 class ArgumentDefaultsHelpFormatter(argparse.RawTextHelpFormatter):
 
     def _get_help_string(self, action):
         return textwrap.dedent(action.help)
 
+
 def main():
     parser = argparse.ArgumentParser(formatter_class=ArgumentDefaultsHelpFormatter)
 
     parser.add_argument('--rom', default='ER_base.sfc', help='Path to an ALttP rom to adjust.')
     parser.add_argument('--baserom', default='Zelda no Densetsu - Kamigami no Triforce (Japan).sfc',
                         help='Path to an ALttP JAP(1.0) rom to use as a base.')
-    parser.add_argument('--loglevel', default='info', const='info', nargs='?', choices=['error', 'info', 'warning', 'debug'], help='Select level of logging for output.')
-    parser.add_argument('--fastmenu', default='normal', const='normal', nargs='?', choices=['normal', 'instant', 'double', 'triple', 'quadruple', 'half'],
+    parser.add_argument('--loglevel', default='info', const='info', nargs='?',
+                        choices=['error', 'info', 'warning', 'debug'], help='Select level of logging for output.')
+    parser.add_argument('--fastmenu', default='normal', const='normal', nargs='?',
+                        choices=['normal', 'instant', 'double', 'triple', 'quadruple', 'half'],
                         help='''\
                              Select the rate at which the menu opens and closes.
                              (default: %(default)s)
                              ''')
     parser.add_argument('--quickswap', help='Enable quick item swapping with L and R.', action='store_true')
     parser.add_argument('--disablemusic', help='Disables game music.', action='store_true')
-    parser.add_argument('--triforcehud', default='hide_goal', const='hide_goal', nargs='?', choices=['normal', 'hide_goal', 'hide_required', 'hide_both'],
-                    help='''\
+    parser.add_argument('--triforcehud', default='hide_goal', const='hide_goal', nargs='?',
+                        choices=['normal', 'hide_goal', 'hide_required', 'hide_both'],
+                        help='''\
                             Hide the triforce hud in certain circumstances.
                             hide_goal will hide the hud until finding a triforce piece, hide_required will hide the total amount needed to win
                             (Both can be revealed when speaking to Murahalda)
                             (default: %(default)s)
                             ''')
-    parser.add_argument('--enableflashing', help='Reenable flashing animations (unfriendly to epilepsy, always disabled in race roms)', action='store_false', dest="reduceflashing")
-    parser.add_argument('--heartbeep', default='normal', const='normal', nargs='?', choices=['double', 'normal', 'half', 'quarter', 'off'],
+    parser.add_argument('--enableflashing',
+                        help='Reenable flashing animations (unfriendly to epilepsy, always disabled in race roms)',
+                        action='store_false', dest="reduceflashing")
+    parser.add_argument('--heartbeep', default='normal', const='normal', nargs='?',
+                        choices=['double', 'normal', 'half', 'quarter', 'off'],
                         help='''\
                              Select the rate at which the heart beep sound is played at
                              low health. (default: %(default)s)
                              ''')
-    parser.add_argument('--heartcolor', default='red', const='red', nargs='?', choices=['red', 'blue', 'green', 'yellow', 'random'],
+    parser.add_argument('--heartcolor', default='red', const='red', nargs='?',
+                        choices=['red', 'blue', 'green', 'yellow', 'random'],
                         help='Select the color of Link\'s heart meter. (default: %(default)s)')
-    parser.add_argument('--ow_palettes', default='default', choices=['default', 'random', 'blackout','puke','classic','grayscale','negative','dizzy','sick'])
-    parser.add_argument('--link_palettes', default='default', choices=['default', 'random', 'blackout','puke','classic','grayscale','negative','dizzy','sick'])
-    parser.add_argument('--shield_palettes', default='default', choices=['default', 'random', 'blackout','puke','classic','grayscale','negative','dizzy','sick'])
-    parser.add_argument('--sword_palettes', default='default', choices=['default', 'random', 'blackout','puke','classic','grayscale','negative','dizzy','sick'])
-    parser.add_argument('--hud_palettes', default='default', choices=['default', 'random', 'blackout','puke','classic','grayscale','negative','dizzy','sick'])
-    parser.add_argument('--uw_palettes', default='default', choices=['default', 'random', 'blackout','puke','classic','grayscale','negative','dizzy','sick'])
+    parser.add_argument('--ow_palettes', default='default',
+                        choices=['default', 'random', 'blackout', 'puke', 'classic', 'grayscale', 'negative', 'dizzy',
+                                 'sick'])
+    parser.add_argument('--link_palettes', default='default',
+                        choices=['default', 'random', 'blackout', 'puke', 'classic', 'grayscale', 'negative', 'dizzy',
+                                 'sick'])
+    parser.add_argument('--shield_palettes', default='default',
+                        choices=['default', 'random', 'blackout', 'puke', 'classic', 'grayscale', 'negative', 'dizzy',
+                                 'sick'])
+    parser.add_argument('--sword_palettes', default='default',
+                        choices=['default', 'random', 'blackout', 'puke', 'classic', 'grayscale', 'negative', 'dizzy',
+                                 'sick'])
+    parser.add_argument('--hud_palettes', default='default',
+                        choices=['default', 'random', 'blackout', 'puke', 'classic', 'grayscale', 'negative', 'dizzy',
+                                 'sick'])
+    parser.add_argument('--uw_palettes', default='default',
+                        choices=['default', 'random', 'blackout', 'puke', 'classic', 'grayscale', 'negative', 'dizzy',
+                                 'sick'])
     parser.add_argument('--sprite', help='''\
                              Path to a sprite sheet to use for Link. Needs to be in
                              binary format and have a length of 0x7000 (28672) bytes,
@@ -64,8 +89,11 @@ def main():
                              sprite that will be extracted.
                              ''')
     parser.add_argument('--names', default='', type=str)
+    parser.add_argument('--update_sprites', action='store_true', help='Update Sprite Database, then exit.')
     args = parser.parse_args()
-
+    if args.update_sprites:
+        run_sprite_update()
+        sys.exit()
     # set up logger
     loglevel = {'error': logging.ERROR, 'info': logging.INFO, 'warning': logging.WARNING, 'debug': logging.DEBUG}[
         args.loglevel]
@@ -99,13 +127,13 @@ def adjust(args):
     else:
         raise RuntimeError(
             'Provided Rom is not a valid Link to the Past Randomizer Rom. Please provide one for adjusting.')
-    palettes_options={}
-    palettes_options['dungeon']=args.uw_palettes
+    palettes_options = {}
+    palettes_options['dungeon'] = args.uw_palettes
 
-    palettes_options['overworld']=args.ow_palettes
-    palettes_options['hud']=args.hud_palettes
-    palettes_options['sword']=args.sword_palettes
-    palettes_options['shield']=args.shield_palettes
+    palettes_options['overworld'] = args.ow_palettes
+    palettes_options['hud'] = args.hud_palettes
+    palettes_options['sword'] = args.sword_palettes
+    palettes_options['shield'] = args.shield_palettes
     # palettes_options['link']=args.link_palettesvera
 
     racerom = rom.read_byte(0x180213) > 0
@@ -123,9 +151,10 @@ def adjust(args):
 
     return args, path
 
+
 def adjustGUI():
-    from tkinter import Checkbutton, OptionMenu, Toplevel, LabelFrame, PhotoImage, Tk, LEFT, RIGHT, BOTTOM, TOP, \
-        StringVar, IntVar, Frame, Label, W, E, X, BOTH, Entry, Spinbox, Button, filedialog, messagebox, ttk
+    from tkinter import Tk, LEFT, BOTTOM, TOP, \
+        StringVar, Frame, Label, X, Entry, Button, filedialog, messagebox, ttk
     from Gui import get_rom_options_frame, get_rom_frame
     from GuiUtils import set_icon
     from argparse import Namespace
@@ -148,6 +177,7 @@ def adjustGUI():
     def RomSelect2():
         rom = filedialog.askopenfilename(filetypes=[("Rom Files", (".sfc", ".smc", ".apbp")), ("All Files", "*")])
         romVar2.set(rom)
+
     romSelectButton2 = Button(romDialogFrame, text='Select Rom', command=RomSelect2)
     romDialogFrame.pack(side=TOP, expand=True, fill=X)
     baseRomLabel2.pack(side=LEFT)
@@ -198,5 +228,16 @@ def adjustGUI():
     adjustWindow.mainloop()
 
 
+def run_sprite_update():
+    import threading
+    done = threading.Event()
+    top = Tk()
+    top.withdraw()
+    BackgroundTaskProgress(top, update_sprites, "Updating Sprites", lambda succesful, resultmessage: done.set())
+    while not done.isSet():
+        top.update()
+    print("Done updating sprites")
+
+
 if __name__ == '__main__':
-    main()
+    main()

LttPClient.py

@@ -1,18 +1,13 @@
 import argparse
 import atexit
 import time
-import functools
-import webbrowser
 import multiprocessing
-import socket
 import os
 import subprocess
 import base64
 import shutil
 from json import loads, dumps
 
-from random import randrange
-
 from Utils import get_item_name_from_id
 
 exit_func = atexit.register(input, "Press enter to close.")
@@ -24,7 +19,6 @@ ModuleUpdate.update()
 import colorama
 
 from NetUtils import *
-import WebUI
 
 from worlds.alttp import Regions, Shops
 from worlds.alttp import Items
@@ -45,12 +39,6 @@ class LttPCommandProcessor(ClientCommandProcessor):
 
         self.output(f"Setting slow mode to {self.ctx.slow_mode}")
 
-    def _cmd_web(self):
-        if self.ctx.webui_socket_port:
-            webbrowser.open(f'http://localhost:5050?port={self.ctx.webui_socket_port}')
-        else:
-            self.output("Web UI was never started.")
-
     @mark_raw
     def _cmd_snes(self, snes_address: str = "") -> bool:
         """Connect to a snes. Optionally include network address of a snes to connect to, otherwise show available devices"""
@@ -69,21 +57,9 @@ class LttPCommandProcessor(ClientCommandProcessor):
 
 class Context(CommonContext):
     command_processor = LttPCommandProcessor
-    def __init__(self, snes_address, server_address, password, found_items, port: int):
+    def __init__(self, snes_address, server_address, password, found_items):
         super(Context, self).__init__(server_address, password, found_items)
 
-        # WebUI Stuff
-        self.ui_node = WebUI.WebUiClient()
-        logger.addHandler(self.ui_node)
-
-        self.webui_socket_port: typing.Optional[int] = port
-        self.hint_cost = 0
-        self.check_points = 0
-        self.forfeit_mode = ''
-        self.remaining_mode = ''
-        self.hint_points = 0
-        # End of WebUI Stuff
-
         # snes stuff
         self.snes_address = snes_address
         self.snes_socket = None
@@ -495,7 +471,7 @@ async def get_snes_devices(ctx: Context):
             reply = loads(await socket.recv())
             devices = reply['Results'] if 'Results' in reply and len(reply['Results']) > 0 else None
 
-    ctx.ui_node.send_device_list(devices)
+
     await socket.close()
     return devices
 
@@ -517,8 +493,6 @@ async def snes_connect(ctx: Context, address):
 
         if len(devices) == 1:
             device = devices[0]
-        elif ctx.ui_node.manual_snes and ctx.ui_node.manual_snes in devices:
-            device = ctx.ui_node.manual_snes
         elif ctx.snes_reconnect_address:
             if ctx.snes_attached_device[1] in devices:
                 device = ctx.snes_attached_device[1]
@@ -538,7 +512,6 @@ async def snes_connect(ctx: Context, address):
         await ctx.snes_socket.send(dumps(Attach_Request))
         ctx.snes_state = SNESState.SNES_ATTACHED
         ctx.snes_attached_device = (devices.index(device), device)
-        ctx.ui_node.send_connection_status(ctx)
 
         if 'sd2snes' in device.lower() or 'COM' in device:
             logger.info("SD2SNES/FXPAK Detected")
@@ -607,7 +580,6 @@ async def snes_recv_loop(ctx: Context):
         ctx.snes_state = SNESState.SNES_DISCONNECTED
         ctx.snes_recv_queue = asyncio.Queue()
         ctx.hud_message_queue = []
-        ctx.ui_node.send_connection_status(ctx)
 
         ctx.rom = None
 
@@ -743,8 +715,6 @@ async def track_locations(ctx: Context, roomid, roomdata):
         ctx.locations_checked.add(location_id)
         location = ctx.location_name_getter(location_id)
         logger.info(f'New Check: {location} ({len(ctx.locations_checked)}/{len(ctx.missing_locations) + len(ctx.checked_locations)})')
-        ctx.ui_node.send_location_check(ctx, location)
-
 
     try:
         if roomid in location_shop_ids:
@@ -887,10 +857,6 @@ async def game_watcher(ctx: Context):
 
         if recv_index < len(ctx.items_received) and recv_item == 0:
             item = ctx.items_received[recv_index]
-            ctx.ui_node.notify_item_received(ctx.player_names[item.player], ctx.item_name_getter(item.item),
-                                             ctx.location_name_getter(item.location), recv_index + 1,
-                                             len(ctx.items_received),
-                                             ctx.item_name_getter(item.item) in Items.progression_items)
             logging.info('Received %s from %s (%s) (%d/%d in list)' % (
                 color(ctx.item_name_getter(item.item), 'red', 'bold'), color(ctx.player_names[item.player], 'yellow'),
                 ctx.location_name_getter(item.location), recv_index + 1, len(ctx.items_received)))
@@ -920,57 +886,6 @@ async def run_game(romfile):
         subprocess.Popen([auto_start, romfile],
                          stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
-
-async def websocket_server(websocket: websockets.WebSocketServerProtocol, path, ctx: Context):
-    endpoint = Endpoint(websocket)
-    ctx.ui_node.endpoints.append(endpoint)
-    process_command = LttPCommandProcessor(ctx)
-    try:
-        async for incoming_data in websocket:
-            data = loads(incoming_data)
-            logging.debug(f"WebUIData:{data}")
-            if ('type' not in data) or ('content' not in data):
-                raise Exception('Invalid data received in websocket')
-
-            elif data['type'] == 'webStatus':
-                if data['content'] == 'connections':
-                    ctx.ui_node.send_connection_status(ctx)
-                elif data['content'] == 'devices':
-                    await get_snes_devices(ctx)
-                elif data['content'] == 'gameInfo':
-                    ctx.ui_node.send_game_info(ctx)
-                elif data['content'] == 'checkData':
-                    ctx.ui_node.send_location_check(ctx, 'Waiting for check...')
-
-            elif data['type'] == 'webConfig':
-                if 'serverAddress' in data['content']:
-                    ctx.server_address = data['content']['serverAddress']
-                    await ctx.connect(data['content']['serverAddress'])
-                elif 'deviceId' in data['content']:
-                    # Allow a SNES disconnect via UI sending -1 as new device
-                    if data['content']['deviceId'] == "-1":
-                        ctx.ui_node.manual_snes = None
-                        ctx.snes_reconnect_address = None
-                        await snes_disconnect(ctx)
-                    else:
-                        await snes_disconnect(ctx)
-                        ctx.ui_node.manual_snes = data['content']['deviceId']
-                        await snes_connect(ctx, ctx.snes_address)
-
-            elif data['type'] == 'webControl':
-                if 'disconnect' in data['content']:
-                    await ctx.disconnect()
-
-            elif data['type'] == 'webCommand':
-                process_command(data['content'])
-
-    except Exception as e:
-        if not isinstance(e, websockets.WebSocketException):
-            logging.exception(e)
-    finally:
-        await ctx.ui_node.disconnect(endpoint)
-
-
 async def main():
     multiprocessing.freeze_support()
     parser = argparse.ArgumentParser()
@@ -982,8 +897,6 @@ async def main():
     parser.add_argument('--loglevel', default='info', choices=['debug', 'info', 'warning', 'error', 'critical'])
     parser.add_argument('--founditems', default=False, action='store_true',
                         help='Show items found by other players for themselves.')
-    parser.add_argument('--web_ui', default=False, action='store_true',
-                        help="Emit a webserver for the webbrowser based user interface.")
     args = parser.parse_args()
     logging.basicConfig(format='%(message)s', level=getattr(logging, args.loglevel.upper(), logging.INFO))
     if args.diff_file:
@@ -1002,23 +915,9 @@ async def main():
         asyncio.create_task(run_game(adjustedromfile if adjusted else romfile))
 
     port = None
-    if args.web_ui:
-        # Find an available port on the host system to use for hosting the websocket server
-        while True:
-            port = randrange(49152, 65535)
-            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-                if not sock.connect_ex(('localhost', port)) == 0:
-                    break
-        import threading
-        WebUI.start_server(
-            port, on_start=threading.Timer(1, webbrowser.open, (f'http://localhost:5050?port={port}',)).start)
 
-    ctx = Context(args.snes, args.connect, args.password, args.founditems, port)
+    ctx = Context(args.snes, args.connect, args.password, args.founditems)
     input_task = asyncio.create_task(console_loop(ctx), name="Input")
-    if args.web_ui:
-        ui_socket = websockets.serve(functools.partial(websocket_server, ctx=ctx),
-                                     'localhost', port, ping_timeout=None, ping_interval=None)
-        await ui_socket
 
     if ctx.server_task is None:
         ctx.server_task = asyncio.create_task(server_loop(ctx), name="ServerLoop")

Main.py

@@ -7,7 +7,7 @@ import time
 import zlib
 import concurrent.futures
 import pickle
-from typing import Dict
+from typing import Dict, Tuple
 
 from BaseClasses import MultiWorld, CollectionState, Region, Item
 from worlds.alttp.Items import ItemFactory, item_name_groups
@@ -26,8 +26,10 @@ from worlds.hk import gen_hollow
 from worlds.hk import create_regions as hk_create_regions
 from worlds.factorio import gen_factorio, factorio_create_regions
 from worlds.factorio.Mod import generate_mod
+from worlds.minecraft import gen_minecraft, fill_minecraft_slot_data, generate_mc_data
+from worlds.minecraft.Regions import minecraft_create_regions
 from worlds.generic.Rules import locality_rules
-from worlds import Games
+from worlds import Games, lookup_any_item_name_to_id
 import Patch
 
 seeddigits = 20
@@ -65,6 +67,7 @@ def main(args, seed=None):
         world.secure()
     else:
         world.random.seed(world.seed)
+    world.seed_name = str(args.outputname if args.outputname else world.seed)
 
     world.shuffle = args.shuffle.copy()
     world.logic = args.logic.copy()
@@ -87,7 +90,6 @@ def main(args, seed=None):
 
     world.hints = args.hints.copy()
 
-    world.remote_items = args.remote_items.copy()
     world.mapshuffle = args.mapshuffle.copy()
     world.compassshuffle = args.compassshuffle.copy()
     world.keyshuffle = args.keyshuffle.copy()
@@ -136,6 +138,8 @@ def main(args, seed=None):
         setattr(world, hk_option, getattr(args, hk_option, {}))
     for factorio_option in Options.factorio_options:
         setattr(world, factorio_option, getattr(args, factorio_option, {}))
+    for minecraft_option in Options.minecraft_options: 
+        setattr(world, minecraft_option, getattr(args, minecraft_option, {}))
     world.glitch_triforce = args.glitch_triforce  # This is enabled/disabled globally, no per player option.
 
     world.rom_seeds = {player: random.Random(world.random.randint(0, 999999999)) for player in range(1, world.players + 1)}
@@ -167,15 +171,16 @@ def main(args, seed=None):
             world.player_names[player].append(name)
 
     logger.info('')
-
     for player in world.alttp_player_ids:
         world.difficulty_requirements[player] = difficulties[world.difficulty[player]]
 
     for player in world.player_ids:
-        for tok in filter(None, args.startinventory[player].split(',')):
-            item = ItemFactory(tok.strip(), player)
-            if item:
-                world.push_precollected(item)
+        for item_name in args.startinventory[player]:
+            item = Item(item_name, True, lookup_any_item_name_to_id[item_name], player)
+            item.game = world.game[player]
+            world.push_precollected(item)
+
+    for player in world.player_ids:
 
         # enforce pre-defined local items.
         if world.goal[player] in ["localtriforcehunt", "localganontriforcehunt"]:
@@ -207,12 +212,15 @@ def main(args, seed=None):
     for player in world.factorio_player_ids:
         factorio_create_regions(world, player)
 
+    for player in world.minecraft_player_ids:
+        minecraft_create_regions(world, player)
+
     for player in world.alttp_player_ids:
         if world.open_pyramid[player] == 'goal':
             world.open_pyramid[player] = world.goal[player] in {'crystals', 'ganontriforcehunt', 'localganontriforcehunt', 'ganonpedestal'}
         elif world.open_pyramid[player] == 'auto':
             world.open_pyramid[player] = world.goal[player] in {'crystals', 'ganontriforcehunt', 'localganontriforcehunt', 'ganonpedestal'} and \
-                                         (world.shuffle[player] in {'vanilla', 'dungeonssimple', 'dungeonsfull'} or not world.shuffle_ganon)
+                                         (world.shuffle[player] in {'vanilla', 'dungeonssimple', 'dungeonsfull', 'dungeonscrossed'} or not world.shuffle_ganon)
         else:
             world.open_pyramid[player] = {'on': True, 'off': False, 'yes': True, 'no': False}.get(world.open_pyramid[player], world.open_pyramid[player])
 
@@ -266,6 +274,9 @@ def main(args, seed=None):
     for player in world.factorio_player_ids:
         gen_factorio(world, player)
 
+    for player in world.minecraft_player_ids:
+        gen_minecraft(world, player)
+
     logger.info("Running Item Plando")
 
     for item in world.itempool:
@@ -305,9 +316,7 @@ def main(args, seed=None):
         balance_multiworld_progression(world)
 
     logger.info('Generating output files.')
-
-    outfilebase = 'AP_%s' % (args.outputname if args.outputname else world.seed)
-
+    outfilebase = 'AP_' + world.seed_name
     rom_names = []
 
     def _gen_rom(team: int, player: int):
@@ -359,8 +368,7 @@ def main(args, seed=None):
                 'U' if world.keyshuffle[player] == "universal" else 'S' if world.keyshuffle[player] else '',
                 'B' if world.bigkeyshuffle[player] else '')
 
-        outfilepname = f'_T{team + 1}' if world.teams > 1 else ''
-        outfilepname += f'_P{player}'
+        outfilepname = f'_P{player}'
         outfilepname += f"_{world.player_names[player][team].replace(' ', '_')}" \
             if world.player_names[player][team] != 'Player%d' % player else ''
         outfilestuffs = {
@@ -403,136 +411,168 @@ def main(args, seed=None):
         rompath = output_path(f'{outfilebase}{outfilepname}{outfilesuffix}.sfc')
         rom.write_to_file(rompath, hide_enemizer=True)
         if args.create_diff:
-            Patch.create_patch_file(rompath)
+            Patch.create_patch_file(rompath, player=player, player_name = world.player_names[player][team])
         return player, team, bytes(rom.name)
 
     pool = concurrent.futures.ThreadPoolExecutor()
-    multidata_task = None
+
     check_accessibility_task = pool.submit(world.fulfills_accessibility)
-    if not args.suppress_rom:
 
-        rom_futures = []
-        mod_futures = []
-        for team in range(world.teams):
-            for player in world.alttp_player_ids:
-                rom_futures.append(pool.submit(_gen_rom, team, player))
-        for player in world.factorio_player_ids:
-            mod_futures.append(pool.submit(generate_mod, world, player))
+    rom_futures = []
+    mod_futures = []
+    for team in range(world.teams):
+        for player in world.alttp_player_ids:
+            rom_futures.append(pool.submit(_gen_rom, team, player))
+    for player in world.factorio_player_ids:
+        mod_futures.append(pool.submit(generate_mod, world, player))
 
-        def get_entrance_to_region(region: Region):
-            for entrance in region.entrances:
-                if entrance.parent_region.type in (RegionType.DarkWorld, RegionType.LightWorld):
-                    return entrance
-            for entrance in region.entrances:  # BFS might be better here, trying DFS for now.
-                return get_entrance_to_region(entrance.parent_region)
+    def get_entrance_to_region(region: Region):
+        for entrance in region.entrances:
+            if entrance.parent_region.type in (RegionType.DarkWorld, RegionType.LightWorld):
+                return entrance
+        for entrance in region.entrances:  # BFS might be better here, trying DFS for now.
+            return get_entrance_to_region(entrance.parent_region)
 
-        # collect ER hint info
-        er_hint_data = {player: {} for player in range(1, world.players + 1) if world.shuffle[player] != "vanilla" or world.retro[player]}
-        from worlds.alttp.Regions import RegionType
-        for region in world.regions:
-            if region.player in er_hint_data and region.locations:
-                main_entrance = get_entrance_to_region(region)
-                for location in region.locations:
-                    if type(location.address) == int:  # skips events and crystals
-                        if lookup_vanilla_location_to_entrance[location.address] != main_entrance.name:
-                            er_hint_data[region.player][location.address] = main_entrance.name
+    # collect ER hint info
+    er_hint_data = {player: {} for player in range(1, world.players + 1) if world.shuffle[player] != "vanilla" or world.retro[player]}
+    from worlds.alttp.Regions import RegionType
+    for region in world.regions:
+        if region.player in er_hint_data and region.locations:
+            main_entrance = get_entrance_to_region(region)
+            for location in region.locations:
+                if type(location.address) == int:  # skips events and crystals
+                    if lookup_vanilla_location_to_entrance[location.address] != main_entrance.name:
+                        er_hint_data[region.player][location.address] = main_entrance.name
 
-        ordered_areas = ('Light World', 'Dark World', 'Hyrule Castle', 'Agahnims Tower', 'Eastern Palace', 'Desert Palace',
-                         'Tower of Hera', 'Palace of Darkness', 'Swamp Palace', 'Skull Woods', 'Thieves Town', 'Ice Palace',
-                         'Misery Mire', 'Turtle Rock', 'Ganons Tower', "Total")
+    ordered_areas = ('Light World', 'Dark World', 'Hyrule Castle', 'Agahnims Tower', 'Eastern Palace', 'Desert Palace',
+                     'Tower of Hera', 'Palace of Darkness', 'Swamp Palace', 'Skull Woods', 'Thieves Town', 'Ice Palace',
+                     'Misery Mire', 'Turtle Rock', 'Ganons Tower', "Total")
 
-        checks_in_area = {player: {area: list() for area in ordered_areas}
-                          for player in range(1, world.players + 1)}
+    checks_in_area = {player: {area: list() for area in ordered_areas}
+                      for player in range(1, world.players + 1)}
 
-        for player in range(1, world.players + 1):
-            checks_in_area[player]["Total"] = 0
+    for player in range(1, world.players + 1):
+        checks_in_area[player]["Total"] = 0
 
-        for location in [loc for loc in world.get_filled_locations() if type(loc.address) is int]:
-            main_entrance = get_entrance_to_region(location.parent_region)
-            if location.game != Games.LTTP:
-                checks_in_area[location.player]["Light World"].append(location.address)
-            elif location.parent_region.dungeon:
-                dungeonname = {'Inverted Agahnims Tower': 'Agahnims Tower',
-                               'Inverted Ganons Tower': 'Ganons Tower'}\
-                    .get(location.parent_region.dungeon.name, location.parent_region.dungeon.name)
-                checks_in_area[location.player][dungeonname].append(location.address)
-            elif main_entrance.parent_region.type == RegionType.LightWorld:
-                checks_in_area[location.player]["Light World"].append(location.address)
-            elif main_entrance.parent_region.type == RegionType.DarkWorld:
-                checks_in_area[location.player]["Dark World"].append(location.address)
-            checks_in_area[location.player]["Total"] += 1
+    for location in [loc for loc in world.get_filled_locations() if type(loc.address) is int]:
+        main_entrance = get_entrance_to_region(location.parent_region)
+        if location.game != Games.LTTP:
+            checks_in_area[location.player]["Light World"].append(location.address)
+        elif location.parent_region.dungeon:
+            dungeonname = {'Inverted Agahnims Tower': 'Agahnims Tower',
+                           'Inverted Ganons Tower': 'Ganons Tower'}\
+                .get(location.parent_region.dungeon.name, location.parent_region.dungeon.name)
+            checks_in_area[location.player][dungeonname].append(location.address)
+        elif main_entrance.parent_region.type == RegionType.LightWorld:
+            checks_in_area[location.player]["Light World"].append(location.address)
+        elif main_entrance.parent_region.type == RegionType.DarkWorld:
+            checks_in_area[location.player]["Dark World"].append(location.address)
+        checks_in_area[location.player]["Total"] += 1
 
-        oldmancaves = []
-        takeanyregions = ["Old Man Sword Cave", "Take-Any #1", "Take-Any #2", "Take-Any #3", "Take-Any #4"]
-        for index, take_any in enumerate(takeanyregions):
-            for region in [world.get_region(take_any, player) for player in range(1, world.players + 1) if world.retro[player]]:
-                item = ItemFactory(region.shop.inventory[(0 if take_any == "Old Man Sword Cave" else 1)]['item'], region.player)
-                player = region.player
-                location_id = SHOP_ID_START + total_shop_slots + index
+    oldmancaves = []
+    takeanyregions = ["Old Man Sword Cave", "Take-Any #1", "Take-Any #2", "Take-Any #3", "Take-Any #4"]
+    for index, take_any in enumerate(takeanyregions):
+        for region in [world.get_region(take_any, player) for player in range(1, world.players + 1) if world.retro[player]]:
+            item = ItemFactory(region.shop.inventory[(0 if take_any == "Old Man Sword Cave" else 1)]['item'], region.player)
+            player = region.player
+            location_id = SHOP_ID_START + total_shop_slots + index
 
-                main_entrance = get_entrance_to_region(region)
-                if main_entrance.parent_region.type == RegionType.LightWorld:
-                    checks_in_area[player]["Light World"].append(location_id)
-                else:
-                    checks_in_area[player]["Dark World"].append(location_id)
-                checks_in_area[player]["Total"] += 1
+            main_entrance = get_entrance_to_region(region)
+            if main_entrance.parent_region.type == RegionType.LightWorld:
+                checks_in_area[player]["Light World"].append(location_id)
+            else:
+                checks_in_area[player]["Dark World"].append(location_id)
+            checks_in_area[player]["Total"] += 1
 
-                er_hint_data[player][location_id] = main_entrance.name
-                oldmancaves.append(((location_id, player), (item.code, player)))
+            er_hint_data[player][location_id] = main_entrance.name
+            oldmancaves.append(((location_id, player), (item.code, player)))
 
-        precollected_items = [[] for player in range(world.players)]
-        for item in world.precollected_items:
-            precollected_items[item.player - 1].append(item.code)
 
-        FillDisabledShopSlots(world)
 
-        def write_multidata(roms, mods):
-            import base64
-            for future in roms:
-                rom_name = future.result()
-                rom_names.append(rom_name)
-            client_versions = {}
-            minimum_versions = {"server": (0, 0, 3), "clients": client_versions}
-            games = {}
-            for slot in world.player_ids:
+    FillDisabledShopSlots(world)
+
+    def write_multidata(roms, mods):
+        import base64
+        import NetUtils
+        for future in roms:
+            rom_name = future.result()
+            rom_names.append(rom_name)
+        slot_data = {}
+        client_versions = {}
+        minimum_versions = {"server": (0, 1, 1), "clients": client_versions}
+        games = {}
+        for slot in world.player_ids:
+            if world.game[slot] == "Factorio":
+                client_versions[slot] = (0, 1, 2)
+            else:
                 client_versions[slot] = (0, 0, 3)
-                games[slot] = world.game[slot]
-            connect_names = {base64.b64encode(rom_name).decode(): (team, slot) for
-                              slot, team, rom_name in rom_names}
+            games[slot] = world.game[slot]
+        connect_names = {base64.b64encode(rom_name).decode(): (team, slot) for
+                          slot, team, rom_name in rom_names}
+        precollected_items = {player: [] for player in range(1, world.players+1)}
+        for item in world.precollected_items:
+            precollected_items[item.player].append(item.code)
+        precollected_hints = {player: set() for player in range(1, world.players+1)}
+        # for now special case Factorio visibility
+        sending_visible_players = set()
+        for player in world.factorio_player_ids:
+            if world.visibility[player]:
+                sending_visible_players.add(player)
 
-            for i, team in enumerate(parsed_names):
-                for player, name in enumerate(team, 1):
-                    if player not in world.alttp_player_ids:
-                        connect_names[name] = (i, player)
+        for i, team in enumerate(parsed_names):
+            for player, name in enumerate(team, 1):
+                if player not in world.alttp_player_ids:
+                    connect_names[name] = (i, player)
+        for slot in world.hk_player_ids:
+            slots_data = slot_data[slot] = {}
+            for option_name in Options.hollow_knight_options:
+                option = getattr(world, option_name)[slot]
+                slots_data[option_name] = int(option.value)
+        for slot in world.minecraft_player_ids:
+            slot_data[slot] = fill_minecraft_slot_data(world, slot)
 
-            multidata = zlib.compress(pickle.dumps({
-                "games": games,
-                "names": parsed_names,
-                "connect_names": connect_names,
-                "remote_items": {player for player in range(1, world.players + 1) if
-                                 world.remote_items[player] or
-                                 world.game[player] != "A Link to the Past"},
-                "locations": {
-                    (location.address, location.player):
-                        (location.item.code, location.item.player)
-                    for location in world.get_filled_locations() if
-                    type(location.address) is int},
-                "checks_in_area": checks_in_area,
-                "server_options": get_options()["server_options"],
-                "er_hint_data": er_hint_data,
-                "precollected_items": precollected_items,
-                "version": tuple(_version_tuple),
-                "tags": ["AP"],
-                "minimum_versions": minimum_versions,
-            }), 9)
+        locations_data: Dict[int, Dict[int, Tuple[int, int]]] = {player: {} for player in world.player_ids}
+        for location in world.get_filled_locations():
+            if type(location.address) == int:
+                locations_data[location.player][location.address] = (location.item.code, location.item.player)
+                if location.player in sending_visible_players and location.item.player != location.player:
+                    hint = NetUtils.Hint(location.item.player, location.player, location.address,
+                                         location.item.code, False)
+                    precollected_hints[location.player].add(hint)
+                    precollected_hints[location.item.player].add(hint)
+                elif location.item.name in args.start_hints[location.item.player]:
+                    hint = NetUtils.Hint(location.item.player, location.player, location.address,
+                                         location.item.code, False,
+                                         er_hint_data.get(location.player, {}).get(location.address, ""))
+                    precollected_hints[location.player].add(hint)
+                    precollected_hints[location.item.player].add(hint)
 
-            with open(output_path('%s.archipelago' % outfilebase), 'wb') as f:
-                f.write(bytes([1]))  # version of format
-                f.write(multidata)
-            for future in mods:
-                future.result() # collect errors if they occured
+        multidata = zlib.compress(pickle.dumps({
+            "slot_data" : slot_data,
+            "games": games,
+            "names": parsed_names,
+            "connect_names": connect_names,
+            "remote_items": {player for player in range(1, world.players + 1) if
+                             world.remote_items[player]},
+            "locations": locations_data,
+            "checks_in_area": checks_in_area,
+            "server_options": get_options()["server_options"],
+            "er_hint_data": er_hint_data,
+            "precollected_items": precollected_items,
+            "precollected_hints": precollected_hints,
+            "version": tuple(_version_tuple),
+            "tags": ["AP"],
+            "minimum_versions": minimum_versions,
+            "seed_name": world.seed_name
+        }), 9)
 
-        multidata_task = pool.submit(write_multidata, rom_futures, mod_futures)
+        with open(output_path('%s.archipelago' % outfilebase), 'wb') as f:
+            f.write(bytes([1]))  # version of format
+            f.write(multidata)
+        for future in mods:
+            future.result() # collect errors if they occured
+
+    multidata_task = pool.submit(write_multidata, rom_futures, mod_futures)
     if not check_accessibility_task.result():
         if not world.can_beat_game():
             raise Exception("Game appears as unbeatable. Aborting.")
@@ -541,9 +581,11 @@ def main(args, seed=None):
     if multidata_task:
         multidata_task.result()  # retrieve exception if one exists
     pool.shutdown()  # wait for all queued tasks to complete
+    for player in world.minecraft_player_ids: # Doing this after shutdown prevents the .apmc from being generated if there's an error
+        generate_mc_data(world, player)
     if not args.skip_playthrough:
         logger.info('Calculating playthrough.')
-    create_playthrough(world)
+        create_playthrough(world)
     if args.create_spoiler:  # needs spoiler.hashes to be filled, that depend on rom_futures being done
         world.spoiler.to_file(output_path('%s_Spoiler.txt' % outfilebase))
 

ModuleUpdate.py

@@ -1,55 +1,48 @@
 import os
 import sys
 import subprocess
-import importlib
+import pkg_resources
 
+requirements_files = {'requirements.txt'}
 
 if sys.version_info < (3, 8, 6):
     raise RuntimeError("Incompatible Python Version. 3.8.7+ is supported.")
 
-update_ran = hasattr(sys, "frozen") and getattr(sys, "frozen")  # don't run update if environment is frozen/compiled
+update_ran = getattr(sys, "frozen", False)  # don't run update if environment is frozen/compiled
+
+if not update_ran:
+    for entry in os.scandir("worlds"):
+        if entry.is_dir():
+            req_file = os.path.join(entry.path, "requirements.txt")
+            if os.path.exists(req_file):
+                requirements_files.add(req_file)
 
 
 def update_command():
-    subprocess.call([sys.executable, '-m', 'pip', 'install', '-r', 'requirements.txt', '--upgrade'])
-
-
-naming_specialties = {"PyYAML": "yaml",  # PyYAML is imported as the name yaml
-                      "maseya-z3pr": "maseya",
-                      "factorio-rcon-py": "factorio_rcon"}
+    for file in requirements_files:
+        subprocess.call([sys.executable, '-m', 'pip', 'install', '-r', file, '--upgrade'])
 
 
 def update():
     global update_ran
     if not update_ran:
         update_ran = True
-        path = os.path.join(os.path.dirname(sys.argv[0]), 'requirements.txt')
-        if not os.path.exists(path):
-            path = os.path.join(os.path.dirname(__file__), 'requirements.txt')
-        with open(path) as requirementsfile:
-            for line in requirementsfile.readlines():
-                module, remote_version = line.split(">=")
-                module = naming_specialties.get(module, module)
-                try:
-                    module = importlib.import_module(module)
-                except:
-                    import traceback
-                    traceback.print_exc()
-                    input(f'Required python module {module} not found, press enter to install it')
-                    update_command()
-                    return
-                else:
-                    if hasattr(module, "__version__"):
-                        module_version = module.__version__
-                        module = module.__name__  # also unloads the module to make it writable
-                        if type(module_version) == str:
-                            module_version = tuple(int(part.strip()) for part in module_version.split("."))
-                        remote_version = tuple(int(part.strip()) for part in remote_version.split("."))
-                        if module_version < remote_version:
-                            input(f'Required python module {module} is outdated ({module_version}<{remote_version}),'
-                                  ' press enter to upgrade it')
-                            update_command()
-                            return
+        for req_file in requirements_files:
+            path = os.path.join(os.path.dirname(sys.argv[0]), req_file)
+            if not os.path.exists(path):
+                path = os.path.join(os.path.dirname(__file__), req_file)
+            with open(path) as requirementsfile:
+                requirements = pkg_resources.parse_requirements(requirementsfile)
+                for requirement in requirements:
+                    requirement = str(requirement)
+                    try:
+                        pkg_resources.require(requirement)
+                    except pkg_resources.ResolutionError:
+                        import traceback
+                        traceback.print_exc()
+                        input(f'Requirement {requirement} is not satisfied, press enter to install it')
+                        update_command()
+                        return
 
 
 if __name__ == "__main__":

MultiMystery.py

@@ -5,6 +5,7 @@ import threading
 import concurrent.futures
 import argparse
 import logging
+import random
 
 
 def feedback(text: str):
@@ -24,8 +25,7 @@ if __name__ == "__main__":
         args = parser.parse_args()
 
         from Utils import get_public_ipv4, get_options
-
-        from Patch import create_patch_file
+        from Mystery import get_seed_name
 
         options = get_options()
 
@@ -40,11 +40,11 @@ if __name__ == "__main__":
         create_spoiler = multi_mystery_options["create_spoiler"]
         zip_roms = multi_mystery_options["zip_roms"]
         zip_diffs = multi_mystery_options["zip_diffs"]
+        zip_apmcs = multi_mystery_options["zip_apmcs"]
         zip_spoiler = multi_mystery_options["zip_spoiler"]
         zip_multidata = multi_mystery_options["zip_multidata"]
         zip_format = multi_mystery_options["zip_format"]
         # zip_password = multi_mystery_options["zip_password"] not at this time
-        player_name = multi_mystery_options["player_name"]
         meta_file_path = multi_mystery_options["meta_file_path"]
         weights_file_path = multi_mystery_options["weights_file_path"]
         pre_roll = multi_mystery_options["pre_roll"]
@@ -89,10 +89,11 @@ if __name__ == "__main__":
             feedback(f"No player files found. Please put them in a {player_files_path} folder.")
         else:
             logging.info(f"{target_player_count} Players found.")
-
+        seed_name = get_seed_name(random)
         command = f"{basemysterycommand} --multi {target_player_count} {player_string} " \
                   f"--rom \"{rom_file}\" --enemizercli \"{enemizer_path}\" " \
-                  f"--outputpath \"{output_path}\" --teams {teams} --plando \"{plando_options}\""
+                  f"--outputpath \"{output_path}\" --teams {teams} --plando \"{plando_options}\" " \
+                  f"--seed_name {seed_name}"
 
         if create_spoiler:
             command += " --create_spoiler"
@@ -117,27 +118,12 @@ if __name__ == "__main__":
         start = time.perf_counter()
         text = subprocess.check_output(command, shell=True).decode()
         logging.info(f"Took {time.perf_counter() - start:.3f} seconds to generate multiworld.")
-        seedname = ""
 
-        for segment in text.split():
-            if segment.startswith("M"):
-                seedname = segment
-                break
-
-        multidataname = f"AP_{seedname}.archipelago"
-        spoilername = f"AP_{seedname}_Spoiler.txt"
+        multidataname = f"AP_{seed_name}.archipelago"
+        spoilername = f"AP_{seed_name}_Spoiler.txt"
         romfilename = ""
 
-        if player_name:
-            for file in os.listdir(output_path):
-                if player_name in file:
-                    import MultiClient
-                    import asyncio
-
-                    asyncio.run(MultiClient.run_game(os.path.join(output_path, file)))
-                    break
-
-        if any((zip_roms, zip_multidata, zip_spoiler, zip_diffs)):
+        if any((zip_roms, zip_multidata, zip_spoiler, zip_diffs, zip_apmcs)):
             import zipfile
 
             compression = {1: zipfile.ZIP_DEFLATED,
@@ -162,7 +148,7 @@ if __name__ == "__main__":
                 logging.info(f"Removed {file} which is now present in the zipfile")
 
 
-            zipname = os.path.join(output_path, f"AP_{seedname}.{typical_zip_ending}")
+            zipname = os.path.join(output_path, f"AP_{seed_name}.{typical_zip_ending}")
 
             logging.info(f"Creating zipfile {zipname}")
             ipv4 = (host if host else get_public_ipv4()) + ":" + str(port)
@@ -171,7 +157,7 @@ if __name__ == "__main__":
             def _handle_sfc_file(file: str):
                 if zip_roms:
                     pack_file(file)
-                    if zip_roms == 2 and player_name.lower() not in file.lower():
+                    if zip_roms == 2:
                         remove_zipped_file(file)
 
 
@@ -182,15 +168,28 @@ if __name__ == "__main__":
                         remove_zipped_file(file)
 
 
+            def _handle_apmc_file(file: str):
+                if zip_apmcs:
+                    pack_file(file)
+                    if zip_apmcs == 2:
+                        remove_zipped_file(file)
+
+
             with concurrent.futures.ThreadPoolExecutor() as pool:
                 futures = []
+                files = os.listdir(output_path)
                 with zipfile.ZipFile(zipname, "w", compression=compression, compresslevel=9) as zf:
-                    for file in os.listdir(output_path):
-                        if seedname in file:
+                    for file in files:
+                        if seed_name in file:
                             if file.endswith(".sfc"):
                                 futures.append(pool.submit(_handle_sfc_file, file))
                             elif file.endswith(".apbp"):
                                 futures.append(pool.submit(_handle_diff_file, file))
+                            elif file.endswith(".apmc"):
+                                futures.append(pool.submit(_handle_apmc_file, file))
+                            # just handle like a diff file for now
+                            elif file.endswith(".zip"):
+                                futures.append(pool.submit(_handle_diff_file, file))
 
                     if zip_multidata and os.path.exists(os.path.join(output_path, multidataname)):
                         pack_file(multidataname)

MultiServer.py

@@ -29,7 +29,7 @@ from worlds.alttp import Items, Regions
 from worlds import network_data_package, lookup_any_item_id_to_name, lookup_any_item_name_to_id, \
     lookup_any_location_id_to_name, lookup_any_location_name_to_id
 import Utils
-from Utils import get_item_name_from_id, get_location_name_from_address, \
+from Utils import get_item_name_from_id, get_location_name_from_id, \
     _version_tuple, restricted_loads, Version
 from NetUtils import Node, Endpoint, ClientStatus, NetworkItem, decode, NetworkPlayer
 
@@ -43,7 +43,7 @@ class Client(Endpoint):
     version = Version(0, 0, 0)
     tags: typing.List[str] = []
 
-    def __init__(self, socket: websockets.server.WebSocketServerProtocol, ctx: Context):
+    def __init__(self, socket: websockets.WebSocketServerProtocol, ctx: Context):
         super().__init__(socket)
         self.auth = False
         self.name = None
@@ -78,7 +78,7 @@ class Context(Node):
         self.connect_names = {} # names of slots clients can connect to
         self.allow_forfeits = {}
         self.remote_items = set()
-        self.locations = {}
+        self.locations:typing.Dict[int, typing.Dict[int, typing.Tuple[int, int]]] = {}
         self.host = host
         self.port = port
         self.server_password = server_password
@@ -112,6 +112,12 @@ class Context(Node):
         self.tags = ['AP']
         self.games = {}
         self.minimum_client_versions: typing.Dict[int, Utils.Version] = {}
+        self.seed_name = ""
+
+    def get_hint_cost(self, slot):
+        if self.hint_cost:
+            return max(0, int(self.hint_cost * 0.01 * len(self.locations[slot])))
+        return 0
 
     def load(self, multidatapath: str, use_embedded_server_options: bool = False):
         with open(multidatapath, 'rb') as f:
@@ -131,7 +137,7 @@ class Context(Node):
 
         mdata_ver = decoded_obj["minimum_versions"]["server"]
         if mdata_ver > Utils._version_tuple:
-            raise RuntimeError(f"Supplied Multidata requires a server of at least version {mdata_ver},"
+            raise RuntimeError(f"Supplied Multidata (.archipelago) requires a server of at least version {mdata_ver},"
                                f"however this server is of version {Utils._version_tuple}")
         clients_ver = decoded_obj["minimum_versions"].get("clients", {})
         self.minimum_client_versions = {}
@@ -141,17 +147,26 @@ class Context(Node):
         for team, names in enumerate(decoded_obj['names']):
             for player, name in enumerate(names, 1):
                 self.player_names[(team, player)] = name
-
+        self.seed_name = decoded_obj["seed_name"]
         self.connect_names = decoded_obj['connect_names']
         self.remote_items = decoded_obj['remote_items']
         self.locations = decoded_obj['locations']
+        self.slot_data = decoded_obj['slot_data']
         self.er_hint_data = {int(player): {int(address): name for address, name in loc_data.items()}
                              for player, loc_data in decoded_obj["er_hint_data"].items()}
         self.games = decoded_obj["games"]
+        # award remote-items start inventory:
+        for team in range(len(decoded_obj['names'])):
+            for slot, item_codes in decoded_obj["precollected_items"].items():
+                if slot in self.remote_items:
+                    self.received_items[team, slot] = [NetworkItem(item_code, -2, 0) for item_code in item_codes]
+            for slot, hints in decoded_obj["precollected_hints"].items():
+                self.hints[team, slot].update(hints)
         if use_embedded_server_options:
             server_options = decoded_obj.get("server_options", {})
             self._set_options(server_options)
 
+
     def get_players_package(self):
         return [NetworkPlayer(t, p, self.get_aliased_name(t, p), n) for (t, p), n in self.player_names.items()]
 
@@ -231,42 +246,40 @@ class Context(Node):
 
     def get_save(self) -> dict:
         d = {
-            "rom_names": list(self.connect_names.items()),
-            "received_items": tuple((k, v) for k, v in self.received_items.items()),
-            "hints_used": tuple((key, value) for key, value in self.hints_used.items()),
-            "hints": tuple(
-                (key, list(hint.re_check(self, key[0]) for hint in value)) for key, value in self.hints.items()),
-            "location_checks": tuple((key, tuple(value)) for key, value in self.location_checks.items()),
-            "name_aliases": tuple((key, value) for key, value in self.name_aliases.items()),
-            "client_game_state": tuple((key, value) for key, value in self.client_game_state.items()),
+            "connect_names": self.connect_names,
+            "received_items": self.received_items,
+            "hints_used": dict(self.hints_used),
+            "hints": dict(self.hints),
+            "location_checks": dict(self.location_checks),
+            "name_aliases": self.name_aliases,
+            "client_game_state": dict(self.client_game_state),
             "client_activity_timers": tuple(
                 (key, value.timestamp()) for key, value in self.client_activity_timers.items()),
             "client_connection_timers": tuple(
                 (key, value.timestamp()) for key, value in self.client_connection_timers.items()),
         }
+
         return d
 
     def set_save(self, savedata: dict):
+        if self.connect_names != savedata["connect_names"]:
+            raise Exception("This savegame does not appear to match the loaded multiworld.")
+        self.received_items = savedata["received_items"]
+        self.hints_used.update(savedata["hints_used"])
+        self.hints.update(savedata["hints"])
 
-        received_items = {tuple(k): [NetworkItem(*i) for i in v] for k, v in savedata["received_items"]}
-
-        self.received_items = received_items
-        self.hints_used.update({tuple(key): value for key, value in savedata["hints_used"]})
-        self.hints.update(
-            {tuple(key): set(NetUtils.Hint(*hint) for hint in value) for key, value in savedata["hints"]})
-
-        self.name_aliases.update({tuple(key): value for key, value in savedata["name_aliases"]})
-        self.client_game_state.update({tuple(key): value for key, value in savedata["client_game_state"]})
+        self.name_aliases.update(savedata["name_aliases"])
+        self.client_game_state.update(savedata["client_game_state"])
         self.client_connection_timers.update(
             {tuple(key): datetime.datetime.fromtimestamp(value, datetime.timezone.utc) for key, value
              in savedata["client_connection_timers"]})
         self.client_activity_timers.update(
             {tuple(key): datetime.datetime.fromtimestamp(value, datetime.timezone.utc) for key, value
              in savedata["client_activity_timers"]})
-        self.location_checks.update({tuple(key): set(value) for key, value in savedata["location_checks"]})
+        self.location_checks.update(savedata["location_checks"])
 
-        logging.info(f'Loaded save file with {sum([len(p) for p in received_items.values()])} received items '
-                     f'for {len(received_items)} players')
+        logging.info(f'Loaded save file with {sum([len(p) for p in self.received_items.values()])} received items '
+                     f'for {len(self.received_items)} players')
 
     def get_aliased_name(self, team: int, slot: int):
         if (team, slot) in self.name_aliases:
@@ -307,16 +320,20 @@ class Context(Node):
 
 
 def notify_hints(ctx: Context, team: int, hints: typing.List[NetUtils.Hint]):
-    cmd = ctx.dumper([{"cmd": "Hint", "hints" : hints}])
-    commands = ctx.dumper([hint.as_network_message() for hint in hints])
-
+    concerns = collections.defaultdict(list)
+    for hint in hints:
+        net_msg = hint.as_network_message()
+        concerns[hint.receiving_player].append(net_msg)
+        if not hint.local:
+            concerns[hint.finding_player].append(net_msg)
     for text in (format_hint(ctx, team, hint) for hint in hints):
         logging.info("Notice (Team #%d): %s" % (team + 1, text))
 
     for client in ctx.endpoints:
         if client.auth and client.team == team:
-            asyncio.create_task(ctx.send_encoded_msgs(client, cmd))
-            asyncio.create_task(ctx.send_encoded_msgs(client, commands))
+            client_hints = concerns[client.slot]
+            if client_hints:
+                asyncio.create_task(ctx.send_msgs(client, client_hints))
 
 
 def update_aliases(ctx: Context, team: int, client: typing.Optional[Client] = None):
@@ -367,7 +384,8 @@ async def on_client_connected(ctx: Context, client: Client):
         'remaining_mode': ctx.remaining_mode,
         'hint_cost': ctx.hint_cost,
         'location_check_points': ctx.location_check_points,
-        'datapackage_version': network_data_package["version"]
+        'datapackage_version': network_data_package["version"],
+        'seed_name': ctx.seed_name
     }])
 
 
@@ -427,10 +445,6 @@ def get_received_items(ctx: Context, team: int, player: int) -> typing.List[Netw
     return ctx.received_items.setdefault((team, player), [])
 
 
-def tuplize_received_items(items):
-    return [NetworkItem(item.item, item.location, item.player) for item in items]
-
-
 def send_new_items(ctx: Context):
     for client in ctx.endpoints:
         if client.auth: # can't send to disconnected client
@@ -439,22 +453,22 @@ def send_new_items(ctx: Context):
                 asyncio.create_task(ctx.send_msgs(client, [{
                     "cmd": "ReceivedItems",
                     "index": client.send_index,
-                    "items": tuplize_received_items(items)[client.send_index:]}]))
+                    "items": items[client.send_index:]}]))
                 client.send_index = len(items)
 
 
 def forfeit_player(ctx: Context, team: int, slot: int):
     # register any locations that are in the multidata
-    all_locations = {location_id for location_id, location_slot in ctx.locations if location_slot == slot}
+    all_locations = set(ctx.locations[slot])
     ctx.notify_all("%s (Team #%d) has forfeited" % (ctx.player_names[(team, slot)], team + 1))
     register_location_checks(ctx, team, slot, all_locations)
 
 
 def get_remaining(ctx: Context, team: int, slot: int) -> typing.List[int]:
     items = []
-    for (location, location_slot) in ctx.locations:
-        if location_slot == slot and location not in ctx.location_checks[team, slot]:
-            items.append(ctx.locations[location, slot][0])  # item ID
+    for location_id in ctx.locations[slot]:
+        if location_id not in ctx.location_checks[team, slot]:
+            items.append(ctx.locations[slot][location_id][0])  # item ID
     return sorted(items)
 
 
@@ -463,15 +477,15 @@ def register_location_checks(ctx: Context, team: int, slot: int, locations: typi
     if new_locations:
         ctx.client_activity_timers[team, slot] = datetime.datetime.now(datetime.timezone.utc)
         for location in new_locations:
-            if (location, slot) in ctx.locations:
-                item_id, target_player = ctx.locations[(location, slot)]
+            if location in ctx.locations[slot]:
+                item_id, target_player = ctx.locations[slot][location]
                 new_item = NetworkItem(item_id, location, slot)
                 if target_player != slot or slot in ctx.remote_items:
                     get_received_items(ctx, team, target_player).append(new_item)
 
                 logging.info('(Team #%d) %s sent %s to %s (%s)' % (
-                team + 1, ctx.player_names[(team, slot)], get_item_name_from_id(item_id),
-                ctx.player_names[(team, target_player)], get_location_name_from_address(location)))
+                    team + 1, ctx.player_names[(team, slot)], get_item_name_from_id(item_id),
+                    ctx.player_names[(team, target_player)], get_location_name_from_id(location)))
                 info_text = json_format_send_event(new_item, target_player)
                 ctx.broadcast_team(team, [info_text])
 
@@ -494,35 +508,32 @@ def notify_team(ctx: Context, team: int, text: str):
 def collect_hints(ctx: Context, team: int, slot: int, item: str) -> typing.List[NetUtils.Hint]:
     hints = []
     seeked_item_id = lookup_any_item_name_to_id[item]
-    for check, result in ctx.locations.items():
-        item_id, receiving_player = result
-        if receiving_player == slot and item_id == seeked_item_id:
-            location_id, finding_player = check
-            found = location_id in ctx.location_checks[team, finding_player]
-            entrance = ctx.er_hint_data.get(finding_player, {}).get(location_id, "")
-            hints.append(NetUtils.Hint(receiving_player, finding_player, location_id, item_id, found, entrance))
+    for finding_player, check_data in ctx.locations.items():
+        for location_id, result in check_data.items():
+            item_id, receiving_player = result
+            if receiving_player == slot and item_id == seeked_item_id:
+                found = location_id in ctx.location_checks[team, finding_player]
+                entrance = ctx.er_hint_data.get(finding_player, {}).get(location_id, "")
+                hints.append(NetUtils.Hint(receiving_player, finding_player, location_id, item_id, found, entrance))
 
     return hints
 
 
 def collect_hints_location(ctx: Context, team: int, slot: int, location: str) -> typing.List[NetUtils.Hint]:
-    hints = []
-    seeked_location = Regions.lookup_name_to_id[location]
-    for check, result in ctx.locations.items():
-        location_id, finding_player = check
-        if finding_player == slot and location_id == seeked_location:
-            item_id, receiving_player = result
-            found = location_id in ctx.location_checks[team, finding_player]
-            entrance = ctx.er_hint_data.get(finding_player, {}).get(location_id, "")
-            hints.append(NetUtils.Hint(receiving_player, finding_player, location_id, item_id, found, entrance))
-            break  # each location has 1 item
-    return hints
+
+    seeked_location: int = Regions.lookup_name_to_id[location]
+    item_id, receiving_player = ctx.locations[slot].get(seeked_location, (None, None))
+    if item_id:
+        found = seeked_location in ctx.location_checks[team, slot]
+        entrance = ctx.er_hint_data.get(slot, {}).get(seeked_location, "")
+        return [NetUtils.Hint(receiving_player, slot, seeked_location, item_id, found, entrance)]
+    return []
 
 
 def format_hint(ctx: Context, team: int, hint: NetUtils.Hint) -> str:
     text = f"[Hint]: {ctx.player_names[team, hint.receiving_player]}'s " \
            f"{lookup_any_item_id_to_name[hint.item]} is " \
-           f"at {get_location_name_from_address(hint.location)} " \
+           f"at {get_location_name_from_id(hint.location)} " \
            f"in {ctx.player_names[team, hint.finding_player]}'s World"
 
     if hint.entrance:
@@ -776,7 +787,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
         if self.ctx.remaining_mode == "enabled":
             remaining_item_ids = get_remaining(self.ctx, self.client.team, self.client.slot)
             if remaining_item_ids:
-                self.output("Remaining items: " + ", ".join(Items.lookup_id_to_name.get(item_id, "unknown item")
+                self.output("Remaining items: " + ", ".join(lookup_any_item_id_to_name.get(item_id, "unknown item")
                                                             for item_id in remaining_item_ids))
             else:
                 self.output("No remaining items found.")
@@ -789,7 +800,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
             if self.ctx.client_game_state[self.client.team, self.client.slot] == ClientStatus.CLIENT_GOAL:
                 remaining_item_ids = get_remaining(self.ctx, self.client.team, self.client.slot)
                 if remaining_item_ids:
-                    self.output("Remaining items: " + ", ".join(Items.lookup_id_to_name.get(item_id, "unknown item")
+                    self.output("Remaining items: " + ", ".join(lookup_any_item_id_to_name.get(item_id, "unknown item")
                                                                 for item_id in remaining_item_ids))
                 else:
                     self.output("No remaining items found.")
@@ -806,7 +817,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
         locations = get_missing_checks(self.ctx, self.client)
 
         if locations:
-            texts = [f'Missing: {get_item_name_from_id(location)}' for location in locations]
+            texts = [f'Missing: {get_location_name_from_id(location)}' for location in locations]
             texts.append(f"Found {len(locations)} missing location checks")
             self.ctx.notify_client_multiple(self.client, texts)
         else:
@@ -854,7 +865,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
         """Use !hint {item_name/location_name}, for example !hint Lamp or !hint Link's House. """
         points_available = get_client_points(self.ctx, self.client)
         if not item_or_location:
-            self.output(f"A hint costs {self.ctx.hint_cost} points. "
+            self.output(f"A hint costs {self.ctx.get_hint_cost(self.client.slot)} points. "
                         f"You have {points_available} points.")
             hints = {hint.re_check(self.ctx, self.client.team) for hint in
                      self.ctx.hints[self.client.team, self.client.slot]}
@@ -875,7 +886,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
                     hints = collect_hints(self.ctx, self.client.team, self.client.slot, item_name)
                 else:  # location name
                     hints = collect_hints_location(self.ctx, self.client.team, self.client.slot, item_name)
-
+                cost = self.ctx.get_hint_cost(self.client.slot)
                 if hints:
                     new_hints = set(hints) - self.ctx.hints[self.client.team, self.client.slot]
                     old_hints = set(hints) - new_hints
@@ -889,8 +900,8 @@ class ClientMessageProcessor(CommonCommandProcessor):
 
                         if not not_found_hints:  # everything's been found, no need to pay
                             can_pay = 1000
-                        elif self.ctx.hint_cost:
-                            can_pay = points_available // self.ctx.hint_cost
+                        elif cost:
+                            can_pay = points_available // cost
                         else:
                             can_pay = 1000
 
@@ -916,7 +927,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
                             else:
                                 self.output(f"You can't afford the hint. "
                                             f"You have {points_available} points and need at least "
-                                            f"{self.ctx.hint_cost}")
+                                            f"{self.ctx.get_hint_cost(self.client.slot)}")
                         notify_hints(self.ctx, self.client.team, hints)
                         self.ctx.save()
                         return True
@@ -931,21 +942,19 @@ class ClientMessageProcessor(CommonCommandProcessor):
 
 def get_checked_checks(ctx: Context, client: Client) -> typing.List[int]:
     return [location_id for
-            location_id, slot in ctx.locations if
-            slot == client.slot and
+            location_id in ctx.locations[client.slot] if
             location_id in ctx.location_checks[client.team, client.slot]]
 
 
 def get_missing_checks(ctx: Context, client: Client) -> typing.List[int]:
     return [location_id for
-            location_id, slot in ctx.locations if
-            slot == client.slot and
+            location_id in ctx.locations[client.slot] if
             location_id not in ctx.location_checks[client.team, client.slot]]
 
 
 def get_client_points(ctx: Context, client: Client) -> int:
     return (ctx.location_check_points * len(ctx.location_checks[client.team, client.slot]) -
-            ctx.hint_cost * ctx.hints_used[client.team, client.slot])
+            ctx.get_hint_cost(client.slot) * ctx.hints_used[client.team, client.slot])
 
 
 async def process_client_cmd(ctx: Context, client: Client, args: dict):
@@ -1001,10 +1010,8 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
                 if minver > args['version']:
                     errors.add('IncompatibleVersion')
 
-        if ctx.compatibility == 1 and "AP" not in args['tags']:
-            errors.add('IncompatibleVersion')
         # only exact version match allowed
-        elif ctx.compatibility == 0 and args['version'] != _version_tuple:
+        if ctx.compatibility == 0 and args['version'] != _version_tuple:
             errors.add('IncompatibleVersion')
         if errors:
             logging.info(f"A client connection was refused due to: {errors}")
@@ -1020,10 +1027,11 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
                 "players": ctx.get_players_package(),
                 "missing_locations": get_missing_checks(ctx, client),
                 "checked_locations": get_checked_checks(ctx, client),
+                "slot_data": ctx.slot_data.get(client.slot, {})
             }]
             items = get_received_items(ctx, client.team, client.slot)
             if items:
-                reply.append({"cmd": 'ReceivedItems', "index": 0, "items": tuplize_received_items(items)})
+                reply.append({"cmd": 'ReceivedItems', "index": 0, "items": items})
                 client.send_index = len(items)
 
             await ctx.send_msgs(client, reply)
@@ -1038,7 +1046,7 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
             if items:
                 client.send_index = len(items)
                 await ctx.send_msgs(client, [{"cmd": "ReceivedItems","index": 0,
-                                              "items": tuplize_received_items(items)}])
+                                              "items": items}])
 
         elif cmd == 'LocationChecks':
             register_location_checks(ctx, client.team, client.slot, args["locations"])
@@ -1046,20 +1054,12 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
         elif cmd == 'LocationScouts':
             locs = []
             for location in args["locations"]:
-                if type(location) is not int or 0 >= location > len(Regions.location_table):
+                if type(location) is not int or location not in lookup_any_location_id_to_name:
                     await ctx.send_msgs(client, [{"cmd": "InvalidArguments", "text": 'LocationScouts'}])
                     return
-                loc_name = list(Regions.location_table.keys())[location - 1]
-                target_item, target_player = ctx.locations[(Regions.location_table[loc_name][0], client.slot)]
+                target_item, target_player = ctx.locations[client.slot][location]
+                locs.append(NetworkItem(target_item, location, target_player))
 
-                replacements = {'SmallKey': 0xA2, 'BigKey': 0x9D, 'Compass': 0x8D, 'Map': 0x7D}
-                item_type = [i[1] for i in Items.item_table.values() if type(i[2]) is int and i[2] == target_item]
-                if item_type:
-                    target_item = replacements.get(item_type[0], target_item)
-
-                locs.append([target_item, location, target_player])
-
-            # logging.info(f"{client.name} in team {client.team+1} scouted {', '.join([l[0] for l in locs])}")
             await ctx.send_msgs(client, [{'cmd': 'LocationInfo', 'locations': locs}])
 
         elif cmd == 'StatusUpdate':
@@ -1205,7 +1205,7 @@ class ServerCommandProcessor(CommonCommandProcessor):
             if usable:
                 for client in self.ctx.endpoints:
                     if client.name == seeked_player:
-                        new_item = NetworkItem(lookup_any_item_name_to_id[item], -1, client.slot)
+                        new_item = NetworkItem(lookup_any_item_name_to_id[item], -1, 0)
                         get_received_items(self.ctx, client.team, client.slot).append(new_item)
                         self.ctx.notify_all('Cheat console: sending "' + item + '" to ' +
                                             self.ctx.get_aliased_name(client.team, client.slot))

Mystery.py

@@ -54,13 +54,15 @@ def mystery_argparse():
                         help='Output rolled mystery results to yaml up to specified number (made for async multiworld)')
     parser.add_argument('--plando', default="bosses",
                         help='List of options that can be set manually. Can be combined, for example "bosses, items"')
-
+    parser.add_argument('--seed_name')
     for player in range(1, multiargs.multi + 1):
         parser.add_argument(f'--p{player}', help=argparse.SUPPRESS)
     args = parser.parse_args()
     args.plando: typing.Set[str] = {arg.strip().lower() for arg in args.plando.split(",")}
     return args
 
+def get_seed_name(random):
+    return f"{random.randint(0, pow(10, seeddigits) - 1)}".zfill(seeddigits)
 
 def main(args=None, callback=ERmain):
     if not args:
@@ -68,9 +70,8 @@ def main(args=None, callback=ERmain):
 
     seed = get_seed(args.seed)
     random.seed(seed)
-
-    seedname = "M" + (f"{random.randint(0, pow(10, seeddigits) - 1)}".zfill(seeddigits))
-    print(f"Generating mystery for {args.multi} player{'s' if args.multi > 1 else ''}, {seedname} Seed {seed}")
+    seed_name = args.seed_name if args.seed_name else get_seed_name(random)
+    print(f"Generating for {args.multi} player{'s' if args.multi > 1 else ''}, {seed_name} Seed {seed}")
 
     if args.race:
         random.seed()  # reset to time-based random source
@@ -112,7 +113,7 @@ def main(args=None, callback=ERmain):
     erargs.glitch_triforce = args.glitch_triforce
     erargs.race = args.race
     erargs.skip_playthrough = args.skip_playthrough
-    erargs.outputname = seedname
+    erargs.outputname = seed_name
     erargs.outputpath = args.outputpath
     erargs.teams = args.teams
 
@@ -195,7 +196,7 @@ def main(args=None, callback=ERmain):
 
                     pre_rolled = dict()
                     pre_rolled["original_seed_number"] = seed
-                    pre_rolled["original_seed_name"] = seedname
+                    pre_rolled["original_seed_name"] = seed_name
                     pre_rolled["pre_rolled"] = vars(settings).copy()
                     if "plando_items" in pre_rolled["pre_rolled"]:
                         pre_rolled["pre_rolled"]["plando_items"] = [item.to_dict() for item in
@@ -302,7 +303,10 @@ def handle_name(name: str, player: int, name_counter: Counter):
                                                                                                    name] > 1 else ''),
                                                                  player=player,
                                                                  PLAYER=(player if player > 1 else '')))
-    return new_name.strip().replace(' ', '_')[:16]
+    new_name = new_name.strip().replace(' ', '_')[:16]
+    if new_name == "Archipelago":
+        raise Exception(f"You cannot name yourself \"{new_name}\"")
+    return new_name
 
 
 def prefer_int(input_data: str) -> typing.Union[str, int]:
@@ -527,6 +531,19 @@ def roll_settings(weights: dict, plando_options: typing.Set[str] = frozenset(("b
             else:
                 raise Exception(f"Could not force item {item} to be world-non-local, as it was not recognized.")
 
+    inventoryweights = weights.get('startinventory', {})
+    startitems = []
+    for item in inventoryweights.keys():
+        itemvalue = get_choice(item, inventoryweights)
+        if isinstance(itemvalue, int):
+            for i in range(int(itemvalue)):
+                startitems.append(item)
+        elif itemvalue:
+            startitems.append(item)
+    ret.startinventory = startitems
+    ret.start_hints = set(weights.get('start_hints', []))
+
+
     if ret.game == "A Link to the Past":
         roll_alttp_settings(ret, weights, plando_options)
     elif ret.game == "Hollow Knight":
@@ -535,15 +552,29 @@ def roll_settings(weights: dict, plando_options: typing.Set[str] = frozenset(("b
     elif ret.game == "Factorio":
         for option_name, option in Options.factorio_options.items():
             if option_name in weights:
-                setattr(ret, option_name, option.from_any(get_choice(option_name, weights)))
+                if issubclass(option, Options.OptionDict):  # get_choice should probably land in the Option class
+                    setattr(ret, option_name, option.from_any(weights[option_name]))
+                else:
+                    setattr(ret, option_name, option.from_any(get_choice(option_name, weights)))
             else:
-                setattr(ret, option_name, option.from_any(option.default))
+                setattr(ret, option_name, option(option.default))
     elif ret.game == "Minecraft":
         for option_name, option in Options.minecraft_options.items():
             if option_name in weights:
                 setattr(ret, option_name, option.from_any(get_choice(option_name, weights)))
             else:
-                setattr(ret, option_name, option.from_any(option.default))
+                setattr(ret, option_name, option(option.default))
+        # bad hardcoded behavior to make this work for now    
+        ret.plando_connections = []
+        if "connections" in plando_options:
+            options = weights.get("plando_connections", [])
+            for placement in options:
+                if roll_percentage(get_choice("percentage", placement, 100)):
+                    ret.plando_connections.append(PlandoConnection(
+                        get_choice("entrance", placement),
+                        get_choice("exit", placement),
+                        get_choice("direction", placement, "both")
+                    ))
     else:
         raise Exception(f"Unsupported game {ret.game}")
     return ret
@@ -696,23 +727,8 @@ def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
         if not ret.required_medallions[index]:
             raise Exception(f"unknown Medallion {medallion} for {'misery mire' if index == 0 else 'turtle rock'}")
 
-    inventoryweights = weights.get('startinventory', {})
-    startitems = []
-    for item in inventoryweights.keys():
-        itemvalue = get_choice(item, inventoryweights)
-        if item.startswith(('Progressive ', 'Small Key ', 'Rupee', 'Piece of Heart', 'Boss Heart Container',
-                            'Sanctuary Heart Container', 'Arrow', 'Bombs ', 'Bomb ', 'Bottle')) and isinstance(
-            itemvalue, int):
-            for i in range(int(itemvalue)):
-                startitems.append(item)
-        elif itemvalue:
-            startitems.append(item)
-    ret.startinventory = ','.join(startitems)
-
     ret.glitch_boots = get_choice('glitch_boots', weights, True)
 
-    ret.remote_items = get_choice('remote_items', weights, False)
-
     if get_choice("local_keys", weights, "l" in dungeon_items):
         # () important for ordering of commands, without them the Big Keys section is part of the Small Key else
         ret.local_items |= item_name_groups["Small Keys"] if ret.keyshuffle else set()

NetUtils.py

@@ -9,6 +9,7 @@ import websockets
 
 from Utils import Version
 
+
 class JSONMessagePart(typing.TypedDict, total=False):
     text: str
     # optional
@@ -18,7 +19,6 @@ class JSONMessagePart(typing.TypedDict, total=False):
     found: bool
 
 
-
 class ClientStatus(enum.IntEnum):
     CLIENT_UNKNOWN = 0
     CLIENT_CONNECTED = 5
@@ -61,10 +61,12 @@ _encode = JSONEncoder(
 def encode(obj):
     return _encode(_scan_for_TypedTuples(obj))
 
+
 def get_any_version(data: dict) -> Version:
     data = {key.lower(): value for key, value in data.items()}  # .NET version classes have capitalized keys
     return Version(int(data["major"]), int(data["minor"]), int(data["build"]))
 
+
 whitelist = {"NetworkPlayer": NetworkPlayer,
              "NetworkItem": NetworkItem,
              }
@@ -73,6 +75,7 @@ custom_hooks = {
     "Version": get_any_version
 }
 
+
 def _object_hook(o: typing.Any) -> typing.Any:
     if isinstance(o, dict):
         hook = custom_hooks.get(o.get("class", None), None)
@@ -82,7 +85,7 @@ def _object_hook(o: typing.Any) -> typing.Any:
         if cls:
             for key in tuple(o):
                 if key not in cls._fields:
-                    del(o[key])
+                    del (o[key])
             return cls(**o)
 
     return o
@@ -151,11 +154,16 @@ class HandlerMeta(type):
         handlers = attrs["handlers"] = {}
         trigger: str = "_handle_"
         for base in bases:
-            handlers.update(base.commands)
+            handlers.update(base.handlers)
         handlers.update({handler_name[len(trigger):]: method for handler_name, method in attrs.items() if
                          handler_name.startswith(trigger)})
 
         orig_init = attrs.get('__init__', None)
+        if not orig_init:
+            for base in bases:
+                orig_init = getattr(base, '__init__', None)
+                if orig_init:
+                    break
 
         def __init__(self, *args, **kwargs):
             # turn functions into bound methods
@@ -167,6 +175,7 @@ class HandlerMeta(type):
         attrs['__init__'] = __init__
         return super(HandlerMeta, mcs).__new__(mcs, name, bases, attrs)
 
+
 class JSONTypes(str, enum.Enum):
     color = "color"
     text = "text"
@@ -178,6 +187,7 @@ class JSONTypes(str, enum.Enum):
     location_id = "location_id"
     entrance_name = "entrance_name"
 
+
 class JSONtoTextParser(metaclass=HandlerMeta):
     def __init__(self, ctx):
         self.ctx = ctx
@@ -236,6 +246,11 @@ class JSONtoTextParser(metaclass=HandlerMeta):
         return self._handle_color(node)
 
 
+class RawJSONtoTextParser(JSONtoTextParser):
+    def _handle_color(self, node: JSONMessagePart):
+        return self._handle_text(node)
+
+
 color_codes = {'reset': 0, 'bold': 1, 'underline': 4, 'black': 30, 'red': 31, 'green': 32, 'yellow': 33, 'blue': 34,
                'magenta': 35, 'cyan': 36, 'white': 37, 'black_bg': 40, 'red_bg': 41, 'green_bg': 42, 'yellow_bg': 43,
                'blue_bg': 44, 'purple_bg': 45, 'cyan_bg': 46, 'white_bg': 47}
@@ -281,7 +296,7 @@ class Hint(typing.NamedTuple):
         add_json_text(parts, " is at ")
         add_json_text(parts, self.location, type="location_id")
         add_json_text(parts, " in ")
-        add_json_text(parts, self.finding_player, type ="player_id")
+        add_json_text(parts, self.finding_player, type="player_id")
         if self.entrance:
             add_json_text(parts, "'s World at ")
             add_json_text(parts, self.entrance, type="entrance_name")
@@ -292,4 +307,8 @@ class Hint(typing.NamedTuple):
         else:
             add_json_text(parts, ".")
 
-        return {"cmd": "PrintJSON", "data": parts, "type": "hint"}
+        return {"cmd": "PrintJSON", "data": parts, "type": "hint"}
+
+    @property
+    def local(self):
+        return self.receiving_player == self.finding_player

Options.py

@@ -3,7 +3,7 @@ import typing
 
 
 class AssembleOptions(type):
-    def __new__(cls, name, bases, attrs):
+    def __new__(mcs, name, bases, attrs):
         options = attrs["options"] = {}
         name_lookup = attrs["name_lookup"] = {}
         for base in bases:
@@ -17,7 +17,7 @@ class AssembleOptions(type):
         # apply aliases, without name_lookup
         options.update({name[6:].lower(): option_id for name, option_id in attrs.items() if
                         name.startswith("alias_")})
-        return super(AssembleOptions, cls).__new__(cls, name, bases, attrs)
+        return super(AssembleOptions, mcs).__new__(mcs, name, bases, attrs)
 
 
 class Option(metaclass=AssembleOptions):
@@ -103,12 +103,45 @@ class Choice(Option):
             f'known options are {", ".join(f"{option}" for option in cls.name_lookup.values())}')
 
     @classmethod
-    def from_any(cls, data: typing.Any):
+    def from_any(cls, data: typing.Any) -> Choice:
         if type(data) == int and data in cls.options.values():
             return cls(data)
         return cls.from_text(str(data))
 
 
+class OptionNameSet(Option):
+    default = frozenset()
+
+    def __init__(self, value: typing.Set[str]):
+        self.value: typing.Set[str] = value
+
+    @classmethod
+    def from_text(cls, text: str) -> OptionNameSet:
+        return cls({option.strip() for option in text.split(",")})
+
+    @classmethod
+    def from_any(cls, data: typing.Any) -> OptionNameSet:
+        if type(data) == set:
+            return cls(data)
+        return cls.from_text(str(data))
+
+
+class OptionDict(Option):
+    default = {}
+
+    def __init__(self, value: typing.Dict[str, typing.Any]):
+        self.value: typing.Dict[str, typing.Any] = value
+
+    @classmethod
+    def from_any(cls, data: typing.Dict[str, typing.Any]) -> OptionDict:
+        if type(data) == dict:
+            return cls(data)
+        else:
+            raise NotImplementedError(f"Cannot Convert from non-dictionary, got {type(data)}")
+
+    def get_option_name(self):
+        return str(self.value)
+
 class Logic(Choice):
     option_no_glitches = 0
     option_minor_glitches = 1
@@ -236,7 +269,8 @@ hollow_knight_skip_options: typing.Dict[str, type(Option)] = {
     "SHADESKIPS": Toggle,
 }
 
-hollow_knight_options: typing.Dict[str, type(Option)] = {**hollow_knight_randomize_options, **hollow_knight_skip_options}
+hollow_knight_options: typing.Dict[str, type(Option)] = {**hollow_knight_randomize_options,
+                                                         **hollow_knight_skip_options}
 
 
 class MaxSciencePack(Choice):
@@ -264,6 +298,7 @@ class TechCost(Choice):
     option_insane = 6
     default = 3
 
+
 class FreeSamples(Choice):
     option_none = 0
     option_single_craft = 1
@@ -271,26 +306,72 @@ class FreeSamples(Choice):
     option_stack = 3
     default = 3
 
+
 class TechTreeLayout(Choice):
     option_single = 0
     option_small_diamonds = 1
     option_medium_diamonds = 2
-    option_pyramid = 3
-    option_funnel = 4
+    option_large_diamonds = 3
+    option_small_pyramids = 4
+    option_medium_pyramids = 5
+    option_large_pyramids = 6
+    option_small_funnels = 7
+    option_medium_funnels = 8
+    option_large_funnels = 9
+    option_funnels = 4
+    alias_pyramid = 6
+    alias_funnel = 9
     default = 0
 
+
 class Visibility(Choice):
     option_none = 0
     option_sending = 1
-    default = 0
+    default = 1
+
+class RecipeTime(Choice):
+    option_vanilla = 0
+    option_fast = 1
+    option_normal = 2
+    option_slow = 4
+    option_chaos = 5
+
+class FactorioStartItems(OptionDict):
+    default = {"burner-mining-drill": 19, "stone-furnace": 19}
+
 
 factorio_options: typing.Dict[str, type(Option)] = {"max_science_pack": MaxSciencePack,
                                                     "tech_tree_layout": TechTreeLayout,
                                                     "tech_cost": TechCost,
                                                     "free_samples": FreeSamples,
-                                                    "visibility": Visibility}
+                                                    "visibility": Visibility,
+                                                    "random_tech_ingredients": Toggle,
+                                                    "starting_items": FactorioStartItems,
+                                                    "recipe_time": RecipeTime}
 
-minecraft_options: typing.Dict[str, type(Option)] = {}
+
+class AdvancementGoal(Choice):
+    option_few = 0
+    option_normal = 1
+    option_many = 2
+    default = 1
+
+
+class CombatDifficulty(Choice):
+    option_easy = 0
+    option_normal = 1
+    option_hard = 2
+    default = 1
+
+
+minecraft_options: typing.Dict[str, type(Option)] = {
+    "advancement_goal": AdvancementGoal,
+    "combat_difficulty": CombatDifficulty,
+    "include_hard_advancements": Toggle,
+    "include_insane_advancements": Toggle,
+    "include_postgame_advancements": Toggle,
+    "shuffle_structures": Toggle
+}
 
 if __name__ == "__main__":
     import argparse

Patch.py

@@ -12,7 +12,7 @@ from typing import Tuple, Optional
 import Utils
 from worlds.alttp.Rom import JAP10HASH
 
-current_patch_version = 1
+current_patch_version = 2
 
 
 def get_base_rom_path(file_name: str = "") -> str:
@@ -43,9 +43,9 @@ def get_base_rom_bytes(file_name: str = "") -> bytes:
 def generate_yaml(patch: bytes, metadata: Optional[dict] = None) -> bytes:
     patch = yaml.dump({"meta": metadata,
                        "patch": patch,
-                       "game": "alttp",
-                       "compatible_version": 1,
+                       "game": "A Link to the Past",
                        # minimum version of patch system expected for patching to be successful
+                       "compatible_version": 1,
                        "version": current_patch_version,
                        "base_checksum": JAP10HASH})
     return patch.encode(encoding="utf-8-sig")
@@ -58,10 +58,13 @@ def generate_patch(rom: bytes, metadata: Optional[dict] = None) -> bytes:
     return generate_yaml(patch, metadata)
 
 
-def create_patch_file(rom_file_to_patch: str, server: str = "", destination: str = None) -> str:
+def create_patch_file(rom_file_to_patch: str, server: str = "", destination: str = None,
+                      player: int = 0, player_name: str = "") -> str:
+    meta = {"server": server, # allow immediate connection to server in multiworld. Empty string otherwise
+            "player_id": player,
+            "player_name": player_name}
     bytes = generate_patch(load_bytes(rom_file_to_patch),
-                           {
-                               "server": server})  # allow immediate connection to server in multiworld. Empty string otherwise
+                           meta)
     target = destination if destination else os.path.splitext(rom_file_to_patch)[0] + ".apbp"
     write_lzma(bytes, target)
     return target

README.md

@@ -4,7 +4,8 @@ Archipelago provides a generic framework for developing multiworld capability fo
 
 Currently, the following games are supported:
 * The Legend of Zelda: A Link to the Past
-* Factorio (Alpha Status)
+* Factorio
+* Minecraft
 
 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

@@ -12,7 +12,7 @@ class Version(typing.NamedTuple):
     minor: int
     build: int
 
-__version__ = "0.0.3"
+__version__ = "0.1.2"
 _version_tuple = tuplize_version(__version__)
 
 import builtins
@@ -170,7 +170,6 @@ def get_default_options() -> dict:
             },
             "factorio_options": {
                 "executable": "factorio\\bin\\x64\\factorio",
-                "script-output": "factorio\\script-output",
             },
             "lttp_options": {
                 "rom_file": "Zelda no Densetsu - Kamigami no Triforce (Japan).sfc",
@@ -189,7 +188,7 @@ def get_default_options() -> dict:
                 "server_password": None,
                 "disable_item_cheat": False,
                 "location_check_points": 1,
-                "hint_cost": 1000,
+                "hint_cost": 10,
                 "forfeit_mode": "goal",
                 "remaining_mode": "goal",
                 "auto_shutdown": 0,
@@ -204,10 +203,10 @@ def get_default_options() -> dict:
                 "weights_file_path": "weights.yaml",
                 "meta_file_path": "meta.yaml",
                 "pre_roll": False,
-                "player_name": "",
                 "create_spoiler": 1,
                 "zip_roms": 0,
                 "zip_diffs": 2,
+                "zip_apmcs": 1,
                 "zip_spoiler": 0,
                 "zip_multidata": 1,
                 "zip_format": 1,
@@ -272,14 +271,14 @@ def get_options() -> dict:
     return get_options.options
 
 
-def get_item_name_from_id(code):
+def get_item_name_from_id(code: int) -> str:
     from worlds import lookup_any_item_id_to_name
     return lookup_any_item_id_to_name.get(code, f'Unknown item (ID:{code})')
 
 
-def get_location_name_from_address(address):
+def get_location_name_from_id(code: int) -> str:
     from worlds import lookup_any_location_id_to_name
-    return lookup_any_location_id_to_name.get(address, f'Unknown location (ID:{address})')
+    return lookup_any_location_id_to_name.get(code, f'Unknown location (ID:{code})')
 
 
 def persistent_store(category: str, key: typing.Any, value: typing.Any):
@@ -346,12 +345,12 @@ def get_adjuster_settings(romfile: str) -> typing.Tuple[str, bool]:
                                   f"Enter yes, no or never: ")
         if adjust_wanted and adjust_wanted.startswith("y"):
             if hasattr(adjuster_settings, "sprite_pool"):
-                from Adjuster import AdjusterWorld
+                from LttPAdjuster import AdjusterWorld
                 adjuster_settings.world = AdjusterWorld(getattr(adjuster_settings, "sprite_pool"))
 
             adjusted = True
-            import Adjuster
-            _, romfile = Adjuster.adjust(adjuster_settings)
+            import LttPAdjuster
+            _, romfile = LttPAdjuster.adjust(adjuster_settings)
 
             if hasattr(adjuster_settings, "world"):
                 delattr(adjuster_settings, "world")
@@ -393,6 +392,11 @@ class RestrictedUnpickler(pickle.Unpickler):
         if module == "NetUtils" and name in {"NetworkItem", "ClientStatus", "Hint"}:
             import NetUtils
             return getattr(NetUtils, name)
+        if module == "Options":
+            import Options
+            obj = getattr(Options, name)
+            if issubclass(obj, Options.Option):
+                return obj
         # Forbid everything else.
         raise pickle.UnpicklingError("global '%s.%s' is forbidden" %
                                      (module, name))

WebHost.py

@@ -2,22 +2,24 @@ import os
 import multiprocessing
 import logging
 
+import ModuleUpdate
+ModuleUpdate.requirements_files.add(os.path.join("WebHostLib", "requirements.txt"))
+ModuleUpdate.update()
+
 from WebHostLib import app as raw_app
 from waitress import serve
 
 from WebHostLib.models import db
 from WebHostLib.autolauncher import autohost
 
-configpath = "config.yaml"
+configpath = os.path.abspath("config.yaml")
 
 
 def get_app():
     app = raw_app
     if os.path.exists(configpath):
         import yaml
-        with open(configpath) as c:
-            app.config.update(yaml.safe_load(c))
-
+        app.config.from_file(configpath, yaml.safe_load)
         logging.info(f"Updated config from {configpath}")
     db.bind(**app.config["PONY"])
     db.generate_mapping(create_tables=True)

WebHostLib/__init__.py

@@ -6,7 +6,6 @@ import socket
 from pony.flask import Pony
 from flask import Flask, request, redirect, url_for, render_template, Response, session, abort, send_from_directory
 from flask_caching import Cache
-from flaskext.autoversion import Autoversion
 from flask_compress import Compress
 
 from .models import *
@@ -48,9 +47,6 @@ app.config["CACHE_TYPE"] = "simple"
 app.config["JSON_AS_ASCII"] = False
 app.config["PATCH_TARGET"] = "archipelago.gg"
 
-app.autoversion = True
-
-av = Autoversion(app)
 cache = Cache(app)
 Compress(app)
 

WebHostLib/api/generate.py

@@ -1,4 +1,6 @@
+import json
 import pickle
+
 from uuid import UUID
 
 from . import api_endpoints
@@ -46,7 +48,7 @@ def generate_api():
             gen = Generation(
                 options=pickle.dumps({name: vars(options) for name, options in gen_options.items()}),
                 # convert to json compatible
-                meta=pickle.dumps({"race": race}), state=STATE_QUEUED,
+                meta=json.dumps({"race": race}), state=STATE_QUEUED,
                 owner=session["_id"])
             commit()
             return {"text": f"Generation of seed {gen.id} started successfully.",
@@ -58,6 +60,7 @@ def generate_api():
         return {"text": "Uncaught Exception:" + str(e)}, 500
 
 
+
 @api_endpoints.route('/status/<suuid:seed>')
 def wait_seed_api(seed: UUID):
     seed_id = seed

WebHostLib/autolauncher.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 import logging
+import json
 import multiprocessing
 from datetime import timedelta, datetime
 import concurrent.futures
@@ -9,6 +10,8 @@ import time
 
 from pony.orm import db_session, select, commit
 
+from Utils import restricted_loads
+
 
 class CommonLocker():
     """Uses a file lock to signal that something is already running"""
@@ -25,6 +28,7 @@ class AlreadyRunningException(Exception):
 if sys.platform == 'win32':
     import os
 
+
     class Locker(CommonLocker):
         def __enter__(self):
             try:
@@ -43,6 +47,7 @@ if sys.platform == 'win32':
 else:  # unix
     import fcntl
 
+
     class Locker(CommonLocker):
         def __enter__(self):
             try:
@@ -78,14 +83,21 @@ def handle_generation_failure(result: BaseException):
 
 
 def launch_generator(pool: multiprocessing.pool.Pool, generation: Generation):
-    options = generation.options
-    logging.info(f"Generating {generation.id} for {len(options)} players")
-
-    meta = generation.meta
-    pool.apply_async(gen_game, (options,),
-                     {"race": meta["race"], "sid": generation.id, "owner": generation.owner},
-                     handle_generation_success, handle_generation_failure)
-    generation.state = STATE_STARTED
+    try:
+        meta = json.loads(generation.meta)
+        options = restricted_loads(generation.options)
+        logging.info(f"Generating {generation.id} for {len(options)} players")
+        pool.apply_async(gen_game, (options,),
+                         {"race": meta["race"],
+                          "sid": generation.id,
+                          "owner": generation.owner},
+                         handle_generation_success, handle_generation_failure)
+    except:
+        generation.state = STATE_ERROR
+        commit()
+        raise
+    else:
+        generation.state = STATE_STARTED
 
 
 def init_db(pony_config: dict):
@@ -138,6 +150,7 @@ multiworlds = {}
 
 guardians = concurrent.futures.ThreadPoolExecutor(2, thread_name_prefix="Guardian")
 
+
 class MultiworldInstance():
     def __init__(self, room: Room, config: dict):
         self.room_id = room.id
@@ -162,7 +175,7 @@ class MultiworldInstance():
             self.process = None
 
     def _collect(self):
-        self.process.join() # wait for process to finish
+        self.process.join()  # wait for process to finish
         self.process = None
         self.guardian = None
 

WebHostLib/downloads.py

@@ -2,12 +2,12 @@ from flask import send_file, Response
 from pony.orm import select
 
 from Patch import update_patch_data
-from WebHostLib import app, Patch, Room, Seed
-
+from WebHostLib import app, Slot, Room, Seed
+import zipfile
 
 @app.route("/dl_patch/<suuid:room_id>/<int:patch_id>")
 def download_patch(room_id, patch_id):
-    patch = Patch.get(id=patch_id)
+    patch = Slot.get(id=patch_id)
     if not patch:
         return "Patch not found"
     else:
@@ -30,8 +30,9 @@ def download_spoiler(seed_id):
 
 @app.route("/dl_raw_patch/<suuid:seed_id>/<int:player_id>")
 def download_raw_patch(seed_id, player_id: int):
-    patch = select(patch for patch in Patch if
-                   patch.player_id == player_id and patch.seed.id == seed_id).first()
+    seed = Seed.get(id=seed_id)
+    patch = select(patch for patch in seed.slots if
+                   patch.player_id == player_id).first()
 
     if not patch:
         return "Patch not found"
@@ -43,3 +44,25 @@ def download_raw_patch(seed_id, player_id: int):
 
         fname = f"P{patch.player_id}_{patch.player_name}_{app.jinja_env.filters['suuid'](seed_id)}.apbp"
         return send_file(patch_data, as_attachment=True, attachment_filename=fname)
+
+@app.route("/slot_file/<suuid:seed_id>/<int:player_id>")
+def download_slot_file(seed_id, player_id: int):
+    seed = Seed.get(id=seed_id)
+    slot_data: Slot = select(patch for patch in seed.slots if
+                   patch.player_id == player_id).first()
+
+    if not slot_data:
+        return "Slot Data not found"
+    else:
+        import io
+
+        if slot_data.game == "Minecraft":
+            fname = f"AP_{app.jinja_env.filters['suuid'](seed_id)}_P{slot_data.player_id}_{slot_data.player_name}.apmc"
+        elif slot_data.game == "Factorio":
+            with zipfile.ZipFile(io.BytesIO(slot_data.data)) as zf:
+                for name in zf.namelist():
+                    if name.endswith("info.json"):
+                        fname = name.rsplit("/", 1)[0]+".zip"
+        else:
+            return "Game download not supported."
+        return send_file(io.BytesIO(slot_data.data), as_attachment=True, attachment_filename=fname)

WebHostLib/generate.py

@@ -1,6 +1,7 @@
 import os
 import tempfile
 import random
+import json
 from collections import Counter
 
 from flask import request, flash, redirect, url_for, session, render_template
@@ -39,7 +40,7 @@ def generate(race=False):
                     gen = Generation(
                         options=pickle.dumps({name: vars(options) for name, options in gen_options.items()}),
                         # convert to json compatible
-                        meta=pickle.dumps({"race": race}), state=STATE_QUEUED,
+                        meta=json.dumps({"race": race}), state=STATE_QUEUED,
                         owner=session["_id"])
                     commit()
 
@@ -79,7 +80,6 @@ def gen_game(gen_options, race=False, owner=None, sid=None):
         erargs.outputname = seedname
         erargs.outputpath = target.name
         erargs.teams = 1
-        erargs.progression_balancing = {}
         erargs.create_diff = True
 
         name_counter = Counter()
@@ -94,10 +94,6 @@ def gen_game(gen_options, race=False, owner=None, sid=None):
 
         erargs.names = ",".join(erargs.name[i] for i in range(1, playercount + 1))
         del (erargs.name)
-
-        erargs.skip_progression_balancing = {player: not balanced for player, balanced in
-                                             erargs.progression_balancing.items()}
-        del (erargs.progression_balancing)
         ERmain(erargs, seed)
 
         return upload_to_db(target.name, owner, sid, race)
@@ -107,7 +103,11 @@ def gen_game(gen_options, race=False, owner=None, sid=None):
                 gen = Generation.get(id=sid)
                 if gen is not None:
                     gen.state = STATE_ERROR
-                    gen.meta = (e.__class__.__name__ + ": "+ str(e)).encode()
+                    meta = json.loads(gen.meta)
+                    meta["error"] = (e.__class__.__name__ + ": "+ str(e))
+                    gen.meta = json.dumps(meta)
+
+                    commit()
         raise
 
 
@@ -122,12 +122,12 @@ def wait_seed(seed: UUID):
     if not generation:
         return "Generation not found."
     elif generation.state == STATE_ERROR:
-        return render_template("seedError.html", seed_error=generation.meta.decode())
+        return render_template("seedError.html", seed_error=generation.meta)
     return render_template("waitSeed.html", seed_id=seed_id)
 
 
 def upload_to_db(folder, owner, sid, race:bool):
-    patches = set()
+    slots = set()
     spoiler = ""
 
     multidata = None
@@ -137,8 +137,8 @@ def upload_to_db(folder, owner, sid, race:bool):
             player_text = file.split("_P", 1)[1]
             player_name = player_text.split("_", 1)[1].split(".", 1)[0]
             player_id = int(player_text.split(".", 1)[0].split("_", 1)[0])
-            patches.add(Patch(data=open(file, "rb").read(),
-                              player_id=player_id, player_name = player_name))
+            slots.add(Slot(data=open(file, "rb").read(),
+                             player_id=player_id, player_name = player_name, game = "A Link to the Past"))
         elif file.endswith(".txt"):
             spoiler = open(file, "rt", encoding="utf-8-sig").read()
         elif file.endswith(".archipelago"):
@@ -146,12 +146,12 @@ def upload_to_db(folder, owner, sid, race:bool):
     if multidata:
         with db_session:
             if sid:
-                seed = Seed(multidata=multidata, spoiler=spoiler, patches=patches, owner=owner,
-                            id=sid, meta={"tags": ["generated"]})
+                seed = Seed(multidata=multidata, spoiler=spoiler, slots=slots, owner=owner,
+                            id=sid, meta=json.dumps({"race": race, "tags": ["generated"]}))
             else:
-                seed = Seed(multidata=multidata, spoiler=spoiler, patches=patches, owner=owner,
-                            meta={"tags": ["generated"]})
-            for patch in patches:
+                seed = Seed(multidata=multidata, spoiler=spoiler, slots=slots, owner=owner,
+                            meta=json.dumps({"race": race, "tags": ["generated"]}))
+            for patch in slots:
                 patch.seed = seed
             if sid:
                 gen = Generation.get(id=sid)

WebHostLib/models.py

@@ -9,12 +9,13 @@ STATE_STARTED = 1
 STATE_ERROR = -1
 
 
-class Patch(db.Entity):
+class Slot(db.Entity):
     id = PrimaryKey(int, auto=True)
     player_id = Required(int)
     player_name = Required(str, 16)
-    data = Required(bytes, lazy=True)
+    data = Optional(bytes, lazy=True)
     seed = Optional('Seed')
+    game = Required(str)
 
 
 class Room(db.Entity):
@@ -37,9 +38,9 @@ class Seed(db.Entity):
     multidata = Required(bytes, lazy=True)
     owner = Required(UUID, index=True)
     creation_time = Required(datetime, default=lambda: datetime.utcnow())
-    patches = Set(Patch)
+    slots = Set(Slot)
     spoiler = Optional(LongStr, lazy=True)
-    meta = Required(Json, lazy=True, default=lambda: {})  # additional meta information/tags
+    meta = Required(str, default=lambda: "{\"race\": false}")  # additional meta information/tags
 
 
 class Command(db.Entity):
@@ -51,6 +52,6 @@ class Command(db.Entity):
 class Generation(db.Entity):
     id = PrimaryKey(UUID, default=uuid4)
     owner = Required(UUID)
-    options = Required(Json, lazy=True)
-    meta = Required(Json, lazy=True)
+    options = Required(buffer, lazy=True)
+    meta = Required(str, default=lambda: "{\"race\": false}")
     state = Required(int, default=0, index=True)

WebHostLib/requirements.txt

@@ -1,7 +1,6 @@
-flask>=1.1.2
+flask>=2.0.1
 pony>=0.7.14
 waitress>=2.0.0
 flask-caching>=1.10.1
-Flask-Autoversion>=0.2.0
 Flask-Compress>=1.9.0
 Flask-Limiter>=1.4

WebHostLib/static/assets/playerSettings.js

@@ -170,6 +170,12 @@ const generateGame = (raceMode = false) => {
     race: raceMode ? '1' : '0',
   }).then((response) => {
     window.location.href = response.data.url;
+  }).catch((error) => {
+    const userMessage = document.getElementById('user-message');
+    userMessage.innerText = 'Something went wrong and your game could not be generated.';
+    userMessage.classList.add('visible');
+    window.scrollTo(0, 0);
+    console.error(error);
   });
 };
 

WebHostLib/static/assets/tutorial/factorio/setup_en.md

@@ -0,0 +1,51 @@
+# Factorio Randomizer Setup Guide
+
+## Required Software
+
+### Server Host
+- [Factorio](https://factorio.com)
+- [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases)
+
+### Players
+- [Factorio](https://factorio.com)
+
+## General Concept
+
+One Server Host exists per Factorio World in an Archipelago Multiworld, any number of modded Factorio players can then connect to that world. From the view of Archipelago, this Factorio host is a client.
+## Installation Procedures
+
+### Dedicated Server Setup
+You need a dedicated isolated Factorio installation that the FactorioClient can take control over, if you intend to both emit a world and play, you need to follow both this setup and the player setup.
+This requires two Factorio installations. The easiest and cheapest way to do so is to either buy or register a Factorio on factorio.com, which allows you to download as many Factorio games as you want.
+1. Download the latest Factorio from https://factorio.com/download for your system, for Windows the recommendation is "win64-manual".
+
+2. Make sure the Factorio you play and the Factorio you use for hosting do not share paths. If you downloaded the "manual" version, this is already the case, otherwise, go into the hosting Factorio's folder and put the following text into its `config-path.cfg`:
+```ini
+config-path=__PATH__executable__/../../config
+use-system-read-write-data-directories=false
+```
+3. Navigate to where you installed Archipelago and open the host.yaml file as text. Find the entry `executable` under `factorio_options` and set it to point to your Factorio. If you put Factorio into your Archipelago folder, this would already match.
+
+
+### Player Setup
+- Manually install the AP mod for the correct world you want to join, then use Factorio's built-in multiplayer.
+
+    
+## Joining a MultiWorld Game
+
+1. Make a fresh world. Using any Factorio, create a savegame with options of your choice and save that world as Archipelago.
+
+2. Take that savegame and put it into your Archipelago folder
+
+3. Install the generated Factorio AP Mod
+
+4. Run FactorioClient, it should launch a Factorio server, which you can control with `/factorio <original factorio commands>`, 
+   
+    * It should say it loaded  the Archipelago mod and found a bridge file. If not, the most likely case is that the mod is not correctly installed or activated.
+
+5. In FactorioClient, do `/connect <Archipelago Server Address>` to join that multiworld. You can find further commands with `/help` as well as `!help` once connected.
+
+    * / commands are run on your local client, ! commands are requests for the AP server
+
+    * Players should be able to connect to your Factorio Server and begin playing.
+

WebHostLib/static/assets/tutorial/minecraft/minecraft_en.md

@@ -0,0 +1,136 @@
+# Minecraft Randomizer Setup Guide
+
+## Required Software
+
+### Server Host
+- [Minecraft Forge](https://files.minecraftforge.net/net/minecraftforge/forge/index_1.16.5.html)
+- [Minecraft Archipelago Randomizer Mod](https://github.com/KonoTyran/Minecraft_AP_Randomizer/releases)
+
+### Players
+- [Minecraft Java Edition](https://www.minecraft.net/en-us/store/minecraft-java-edition)
+
+## Installation Procedures
+
+### Dedicated Server Setup
+Only one person has to do this setup and host a dedicated server for everyone else playing to connect to.
+1. Download the 1.16.5 **Minecraft Forge** installer from the link above, making sure to download the most recent recommended version.
+
+2. Run the `forge-1.16.5-xx.x.x-installer.jar` file and choose **install server**.
+    - On this page you will also choose where to install the server to remember this directory it's important in the next step.
+
+3. Navigate to where you installed the server and open `forge-1.16.5-xx.x.x.jar`
+    - Upon first launch of the server it will close and ask you to accept Minecraft's EULA. There will be a new file called `eula.txt` that contains a link to Minecraft's EULA, and a line that you need to change to `eula=true` to accept Minecraft's EULA.
+    - This will create the appropriate directories for you to place the files in the following step.
+
+4. Place the `aprandomizer-x.x.x.jar` from the link above file into the `mods` folder of the above installation of your forge server.
+    - Once again run the server, it will load up and generate the required directory `APData` for when you are ready to play a game!
+
+### Basic Player Setup
+- Purchase and install Minecraft from the above link.
+
+  **You're Done**.
+  
+  Players only need to have a Vanilla unmodified version of Minecraft to play!
+
+### Advanced Player Setup
+***This is not required to play a randomized minecraft game.***
+however this recommended as it helps make the experience more enjoyable.
+
+#### Recomended Mods
+- [JourneyMap](https://www.curseforge.com/minecraft/mc-mods/journeymap) (Minimap)
+
+
+1. Install and run Minecraft from the link above at least once.
+2. Run the `forge-1.16.5-xx.x.x-installer.jar` file and choose **install client**.
+    - Start Minecraft forge at least once to create the directories needed for the next steps.
+3. Navigate to your minecraft install directory and place desired mods `.jar` file the in the `mods` directory.
+    - The default install directories are as follows.
+        - Windows `%APPDATA%\.minecraft\mods`
+        - macOS `~/Library/Application Support/minecraft/mods`
+        - Linux `~/.minecraft/mods`
+
+## Configuring your YAML file
+
+### What is a YAML file and why do I need one?
+Your YAML file contains a set of configuration options which provide the generator with information about how
+it should generate your game. Each player of a multiworld will provide their own YAML file. This setup allows
+each player to enjoy an experience customized for their taste, and different players in the same multiworld
+can all have different options.
+
+### Where do I get a YAML file?
+A basic minecraft yaml will look like this.
+```yaml
+description: Template Name
+# Your name in-game. Spaces will be replaced with underscores and
+# there is a 16 character limit
+name: YourName 
+game: Minecraft
+
+# Shared Options supported by all games:
+accessibility: locations
+progression_balancing: on
+# Minecraft Specific Options
+
+# Number of advancements required (out of 92 total) to spawn the
+# Ender Dragon and complete the game. 
+advancement_goal:
+  few: 0 #30
+  normal: 1 #50
+  many: 0 #70
+  
+# Modifies the level of items logically required for exploring
+# dangerous areas and fighting bosses. 
+combat_difficulty:
+  easy: 0
+  normal: 1
+  hard: 0
+  
+# Junk-fills certain RNG-reliant or tedious advancements with XP rewards. 
+include_hard_advancements:
+  on: 0
+  off: 1
+  
+# Junk-fills extremely difficult advancements;
+# this is only How Did We Get Here? and Adventuring Time.
+include_insane_advancements:
+  on: 0
+  off: 1
+  
+# Some advancements require defeating the Ender Dragon;
+# this will junk-fill them so you won't have to finish to send some items. 
+include_postgame_advancements:
+  on: 0
+  off: 1
+  
+#enables shuffling of villages, outposts, fortresses, bastions, and end cities. 
+shuffle_structures:
+  on: 1
+  off: 0
+```
+
+
+## Joining a MultiWorld Game
+
+### Obtain your Minecraft data file
+**Only one yaml file needs to be submitted per minecraft world regardless of how many players play on it.**
+
+When you join a multiworld game, you will be asked to provide your YAML file to whoever is hosting. Once that
+is done, the host will provide you with either a link to download your data file, or with a zip file containing
+everyone's data files. Your data file should have a `.apmc` extension.
+
+Put your data file in your forge servers `APData` folder. Make sure to remove any previous data file that was in there
+previously.
+
+### Connect to the MultiServer
+After having placed your data file in the `APData` folder, start the Forge server and make sure you have OP
+status by typing `/op YourMinecraftUsername` in the forge server console then connecting in your Minecraft client.
+
+Once in game type `/connect <AP-Address> (Port) (Password)` where `<AP-Address>` is the address of the
+Archipelago server. `(Port)` is only required if the Archipelago server is not using the default port of 38281. `(Password)`
+is only required if the Archipleago server you are using has a password set.
+
+### Play the game
+When the console tells you that you have joined the room, you're ready to begin playing. Congratulations
+on successfully joining a multiworld game! At this point any additional minecraft players may connect to your
+forge server.
+

WebHostLib/static/assets/tutorial/minecraft/minecraft_es.md

@@ -0,0 +1,121 @@
+# Guia instalación de Minecraft Randomizer
+
+## Software Requerido
+
+### Servidor
+- [Minecraft Forge](https://files.minecraftforge.net/net/minecraftforge/forge/index_1.16.5.html)
+- [Minecraft Archipelago Randomizer Mod](https://github.com/KonoTyran/Minecraft_AP_Randomizer/releases)
+
+### Jugadores
+- [Minecraft Java Edition](https://www.minecraft.net/en-us/store/minecraft-java-edition)
+
+## Procedimiento de instalación
+
+### Instalación de servidor dedicado
+Solo una persona ha de realizar este proceso y hospedar un servidor dedicado para que los demas jueguen conectandose a él.
+1. Descarga el instalador de **Minecraft Forge** 1.16.15 desde el enlace proporcionado, siempre asegurandose de bajar la version mas reciente.
+
+2. Ejecuta el fichero `forge-1.16.5-xx.x.x-installer.jar` y elije **install server**.
+    - En esta pagina elegiras ademas donde instalar el servidor, importante recordar esta localización en el siguiente paso.
+
+3. Navega al directorio donde hayas instalado el servidor y abre `forge-1.16.5-xx.x.x.jar`
+    - La primera vez que lances el servidor se cerrara (o no aparecerá nada en absoluto), debería haber un fichero nuevo en el directorio llamado `eula.txt`, el cual que contiene un enlace al EULA de minecraft, cambia la linea a `eula=true` para aceptar el EULA y poder utilizar el software de servidor.
+    - Esto creara la estructura de directorios apropiada para el siguiente paso
+
+4. Coloca el fichero `aprandomizer-x.x.x.jar` del segundo enlace en el directorio `mods`
+    - Cuando se ejecute el servidor de nuevo, generara el directorio `APData` que se necesitara para jugar
+
+### Instalación basica para jugadores
+- Compra e instala Minecraft a traves del tercer enlace.
+  **Y listo!**.
+  Los jugadores solo necesitan una version no modificada de Minecraft para jugar!
+
+### Instalación avanzada para jugadores
+***Esto no es requerido para jugar a minecraft randomizado.***
+Sin embargo lo recomendamos porque hace la experiencia mas llevadera.
+
+#### Recomended Mods
+- [JourneyMap](https://www.curseforge.com/minecraft/mc-mods/journeymap) (Minimap)
+
+
+1. Instala y ejecuta Minecraft al menos una vez.
+2. Ejecuta el fichero `forge-1.16.5-xx.x.x-installer.jar` y elige **install client**.
+    - Ejecuta Minecraft forge al menos una vez para generar los directorios necesarios para el siguiente paso.
+3. Navega a la carpeta de instalación de Minecraft y colocal los mods que quieras en el directorio `mods`
+    - Los directorios por defecto de instalación son:
+        - Windows `%APPDATA%\.minecraft\mods`
+        - macOS `~/Library/Application Support/minecraft/mods`
+        - Linux `~/.minecraft/mods`
+
+## Configura tu fichero YAML
+
+### Que es un fichero YAML y potque necesito uno?
+Tu fichero YAML contiene un numero de opciones que proveen al generador con informacion sobre como debe generar tu juego.
+Cada jugador de un multiworld entregara u propio fichero YAML.
+Esto permite que cada jugador disfrute de una experiencia personalizada a su gusto y diferentes jugadores dentro del mismo multiworld
+pueden tener diferentes opciones
+
+### Where do I get a YAML file?
+Un fichero basico yaml para minecraft tendra este aspecto.
+```yaml
+# Usado para describir tu yaml. Util si tienes multiples ficheros
+description: Template Name 
+# Tu nombre en el juego. Los espacios son reemplazados por guiones bajos, limitado a 16 caracteres
+name: YourName 
+game: Minecraft
+accessibility: locations
+# Recomendado no activar esto ya que el pool de objetos de Minecraft es bastante escueto, ademas hay muchas maneras alternativas de obtener los objetivos de Minecraft.
+progression_balancing: off 
+# Cuantos avances se necesitan para hacer aparecer el Ender Dragon y acabar el juego. few = 30, normal = 50 , many = 70
+advancement_goal: 
+  few: 0 
+  normal: 1 
+  many: 0 
+# Modifica el nivel de objetos lógicamente requeridos para explorar areas peligrosas y pelear contra jefes. 
+combat_difficulty: 
+  easy: 0
+  normal: 1
+  hard: 0
+# Avances que sean tediosos o basados en suerte tendran simplemente experiencia o cosas no necesarias
+include_hard_advancements: 
+  on: 0
+  off: 1
+# Los avances extremadamente difíciles no seran requeridos; esto afecta a How Did We Get Here? y Adventuring Time. 
+include_insane_advancements: 
+  on: 0
+  off: 1
+# Los avances posteriores a Ender Dragon no tendrán objetos necesarios para que otros jugadores en el caso de un MW acaben su partida.
+include_postgame_advancements:
+  on: 0
+  off: 1
+# Actualmente desactivado; permite la mezcla de pueblos, puestos, fortalezas, bastiones y cuidades. 
+shuffle_structures: 
+  on: 0
+  off: 1
+```
+
+
+## Unirse a un juego MultiWorld
+
+### Obten tu ficheros de datos Minecraft
+**Solo un fichero yaml es necesario por mundo minecraft, sin importar el numero de jugadores que jueguen en el.**
+
+Cuando te unes a un juego multiworld, se te pedirá que entregues tu fichero YAML a quien sea que hospede el juego multiworld (no confundir con hospedar el mundo minecraft).
+Una vez la generación acabe, el anfitrión te dará un enlace a tu fichero de datos o un zip con los ficheros de todos.
+Tu fichero de datos tiene una extensión `.apmc`.
+
+Pon tu fichero de datos en el directorio `APData` de tu forge server. Asegurate de eliminar los que hubiera anteriormente
+
+
+### Conectar al multiserver
+Despues de poner tu fichero en el directorio `APData`, arranca el Forge server y asegurate que tienes el estado OP
+tecleando `/op TuUsuarioMinecraft` en la consola del servidor y entonces conectate con tu cliente Minecraft.
+
+Una vez en juego introduce `/connect <AP-Address> (<Password>)` donde `<AP-Address>` es la dirección del servidor
+Archipelago. `(<Password>)`
+solo se necesita si el servidor Archipleago tiene un password activo.
+
+### Jugar al juego
+Cuando la consola te diga que te has unido a la sala, estas lista/o para empezar a jugar. Felicidades
+por unirte exitosamente a un juego multiworld! Llegados a este punto cualquier jugador adicional puede conectarse a tu servidor forge.
+

WebHostLib/static/assets/tutorial/minecraft/minecraft_sv.md

@@ -0,0 +1,114 @@
+# Minecraft Randomizer Uppsättningsguide
+
+## Nödvändig Mjukvara
+
+### Server Värd
+- [Minecraft Forge](https://files.minecraftforge.net/net/minecraftforge/forge/index_1.16.5.html)
+- [Minecraft Archipelago Randomizer Mod](https://github.com/KonoTyran/Minecraft_AP_Randomizer/releases)
+
+### Spelare
+- [Minecraft Java Edition](https://www.minecraft.net/en-us/store/minecraft-java-edition)
+
+## Installationsprocedurer
+
+### Tillägnad
+Bara en person behöver göra denna uppsättning och vara värd för en server för alla andra spelare att koppla till.
+1. Ladda ner 1.16.5 **Minecraft Forge** installeraren från länken ovanför och se till att ladda ner den senaste rekommenderade versionen.
+
+2. Kör `forge-1.16.5-xx.x.x-installer.jar` filen och välj **installera server**.
+    - På denna sida kommer du också välja vart du ska installera servern för att komma ihåg denna katalog. Detta är viktigt för nästa steg.
+
+3. Navigera till vart du har installerat servern och öppna `forge-1.16.5-xx.x.x-installer.jar`
+    - Under första serverstart så kommer den att stängas ner och fråga dig att acceptera Minecrafts EULA. En ny fil kommer skapas vid namn `eula.txt` som har en länk till Minecrafts EULA, och en linje som du behöver byta till `eula=true` för att acceptera Minecrafts EULA.
+    - Detta kommer skapa de lämpliga katalogerna för dig att placera filerna i de följande steget.
+
+4. Placera `aprandomizer-x.x.x.jar` länken ovanför i `mods` mappen som ligger ovanför installationen av din forge server.
+    - Kör servern igen. Den kommer ladda up och generera den nödvändiga katalogen `APData` för när du är redo att spela!
+
+### Grundläggande Spelaruppsättning
+- Köp och installera Minecraft från länken ovanför.
+
+  **Du är klar**.
+
+  Andra spelare behöver endast ha en 'Vanilla' omodifierad version av Minecraft för att kunna spela!
+
+### Avancerad Spelaruppsättning
+***Detta är inte nödvändigt för att spela ett slumpmässigt Minecraftspel.***
+Dock så är det rekommenderat eftersom det hjälper att göra upplevelsen mer trevligt.
+
+#### Rekommenderade Moddar
+- [JourneyMap](https://www.curseforge.com/minecraft/mc-mods/journeymap) (Minimap)
+
+
+1. Installera och Kör Minecraft från länken ovanför minst en gång.
+2. Kör `forge-1.16.5-xx.x.x-installer.jar` filen och välj **installera klient**.
+    - Starta Minecraft Forge minst en gång för att skapa katalogerna som behövs för de nästa stegen.
+3. Navigera till din Minecraft installationskatalog och placera de önskade moddarna med `.jar`  i `mods` -katalogen.
+    - Standardinstallationskatalogerna är som följande;
+        - Windows `%APPDATA%\.minecraft\mods`
+        - macOS `~/Library/Application Support/minecraft/mods`
+        - Linux `~/.minecraft/mods`
+
+## Konfigurera Din YAML-fil
+
+### Vad är en YAML-fil och varför behöver jag en?
+Din YAML-fil behåller en uppsättning av konfigurationsalternativ som ger generatorn med information om hur
+den borde generera ditt spel. Varje spelare i en multivärld kommer behöva ge deras egen YAML-fil. Denna uppsättning tillåter
+varje spelare att an njuta av en upplevelse anpassade för deras smaker, och olika spelare i samma multivärld
+kan ha helt olika alternativ.
+
+### Vart kan jag få tag i en YAML-fil?
+En grundläggande Minecraft YAML kommer se ut så här.
+```yaml
+description: Template Name
+# Ditt spelnamn. Mellanslag kommer bli omplacerad med understräck och det är en 16-karaktärsgräns.
+name: YourName 
+game: Minecraft
+accessibility: locations
+progression_balancing: off
+advancement_goal:
+  few: 0
+  normal: 1
+  many: 0
+combat_difficulty:
+  easy: 0
+  normal: 1
+  hard: 0
+include_hard_advancements:
+  on: 0
+  off: 1
+include_insane_advancements:
+  on: 0
+  off: 1
+include_postgame_advancements:
+  on: 0
+  off: 1
+shuffle_structures:
+  on: 1
+  off: 0
+```
+
+För mer detaljer om vad varje inställning gör, kolla standardinställningen `PlayerSettings.yaml` som kommer med Archipelago-installationen.
+
+## Gå med i ett Multivärld-spel
+
+### Skaffa din Minecraft data-fil
+**Endast en YAML-fil behöver användats per Minecraft-värld oavsett hur många spelare det är som spelar.**
+
+När du går med it ett Multivärld spel så kommer du bli ombedd att lämna in din YAML-fil till personen som värdar. När detta
+är klart så kommer värden att ge dig antingen en länk till att ladda ner din data-fil,  eller mer en zip-fil som innehåller allas data-filer.
+Din data-fil borde ha en `.apmc` -extension.
+
+Lägg din data-fil i dina forge-servrar `APData` -mapp. Se till att ta bort alla tidigare data-filer som var i där förut.
+
+### Koppla till Multiservern
+Efter du har placerat din data-fil i `APData` -mappen, starta forge-servern och se till att you har OP-status
+genom att skriva `/op DittAnvändarnamn` i forger-serverns konsol innan du kopplar dig till din Minecraft klient.
+När du är inne i spelet, skriv `/connect <AP-Address> (<Lösenord>)` där `<AP-Address>` är addressen av
+Archipelago-servern. `(<Lösenord>)` är endast nödvändigt om Archipelago-servern som du använder har ett tillsatt lösenord.
+
+### Spela spelet
+När konsolen har informerat att du har gått med i rummet så är du redo att börja spela. Grattis
+att du har lykats med att gått med i ett Multivärld-spel! Vid detta tillfälle, alla ytterligare Minecraft-spelare må koppla
+in till din forge-server.
+

WebHostLib/static/assets/tutorial/tutorials.json

@@ -85,5 +85,59 @@
         ]
       }
     ]
+  },
+  {
+    "gameTitle": "Factorio",
+    "tutorials": [
+      {
+        "name": "Multiworld Setup Tutorial",
+        "description": "A guide to setting up the Archipelago Factorio software on your computer.",
+        "files": [
+          {
+            "language": "English",
+            "filename": "factorio/setup_en.md",
+            "link": "factorio/setup/en",
+            "authors": [
+              "Berserker"
+            ]
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "gameTitle": "Minecraft",
+    "tutorials": [
+      {
+        "name": "Multiworld Setup Tutorial",
+        "description": "A guide to setting up the Archipelago Minecraft software on your computer. This guide covers single-player, multiworld, and related software.",
+        "files": [
+          {
+            "language": "English",
+            "filename": "minecraft/minecraft_en.md",
+            "link": "minecraft/minecraft/en",
+            "authors": [
+              "Kono Tyran"
+            ]
+          },
+          {
+            "language": "Spanish",
+            "filename": "minecraft/minecraft_es.md",
+            "link": "minecraft/minecraft/es",
+            "authors": [
+              "Edos"
+            ]
+          },
+          {
+            "language": "Swedish",
+            "filename": "minecraft/minecraft_sv.md",
+            "link": "minecraft/minecraft/sv",
+            "authors": [
+              "Albinum"
+            ]
+          }
+        ]
+      }
+    ]
   }
 ]

WebHostLib/static/assets/tutorial/zelda3/multiworld_de.md

@@ -1,13 +1,7 @@
 # A Link to the Past Randomizer Setup Guide
 
-<div id="tutorial-video-container">
-    <iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/icWPmse0Z3E" frameborder="0"
-      allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen>
-    </iframe>
-</div>
-
 ## Benötigte Software
-- [MultiWorld Utilities](https://github.com/Berserker66/MultiWorld-Utilities/releases)
+- [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases)
 - [QUsb2Snes](https://github.com/Skarsnik/QUsb2snes/releases) (Included in the above Utilities)
 - Hardware oder Software zum Laden und Abspielen von SNES Rom-Dateien
     - Ein Emulator, der lua-scripts abspielen kann
@@ -21,7 +15,7 @@
 ### Windows
 1. Lade die Multiworld Utilities herunter und führe die Installation aus. Sei sicher, dass du immer die
 aktuellste Version installiert hast.**Die Datei befindet sich im "assets"-Kasten unter der jeweiligen Versionsinfo!**.
-Für normale Multiworld-Spiele lädst du die `Setup.BerserkerMultiworld.exe` herunter.
+Für normale Multiworld-Spiele lädst du die `Setup.Archipelago.exe` herunter.
     - Für den Doorrandomizer muss die alternative doors-Variante geladen werden. 
     - Während der Installation fragt dich das Programm nach der japanischen 1.0 ROM-Datei. Wenn du die Software	
       bereits installiert hast und einfach nur updaten willst, wirst du nicht nochmal danach gefragt.

WebHostLib/static/assets/tutorial/zelda3/multiworld_en.md

@@ -7,7 +7,7 @@
 </div>
 
 ## Required Software
-- [MultiWorld Utilities](https://github.com/Berserker66/MultiWorld-Utilities/releases)
+- [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases)
 - [QUsb2Snes](https://github.com/Skarsnik/QUsb2snes/releases) (Included in the above Utilities)
 - Hardware or software capable of loading and playing SNES ROM files
     - An emulator capable of running Lua scripts
@@ -21,7 +21,7 @@
 ### Windows Setup
 1. Download and install the MultiWorld Utilities from the link above, making sure to install the most recent version.
 **The file is located in the assets section at the bottom of the version information**. If you intend to play normal
-multiworld games, you want `Setup.BerserkerMultiWorld.exe`
+multiworld games, you want `Setup.Archipelago.exe`
     - If you intend to play the doors variant of multiworld, you will want to download the alternate doors file.
     - During the installation process, you will be asked to browse for your Japanese 1.0 ROM file. If you have
       installed this software before and are simply upgrading now, you will not be prompted to locate your
@@ -144,7 +144,7 @@ on successfully joining a multiworld game!
 
 ## Hosting a MultiWorld game
 The recommended way to host a game is to use the hosting service provided on
-[the website](https://berserkermulti.world/generate). The process is relatively simple:
+[the website](/generate). The process is relatively simple:
 
 1. Collect YAML files from your players.
 2. Create a zip file containing your players' YAML files.

WebHostLib/static/assets/tutorial/zelda3/multiworld_es.md

@@ -7,7 +7,7 @@
 </div>
 
 ## Software requerido
-- [MultiWorld Utilities](https://github.com/Berserker66/MultiWorld-Utilities/releases)
+- [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases)
 - [QUsb2Snes](https://github.com/Skarsnik/QUsb2snes/releases) (Incluido en Multiworld Utilities)
 - Hardware o software capaz de cargar y ejecutar archivos de ROM de SNES
     - Un emulador capaz de ejecutar scripts Lua
@@ -20,7 +20,7 @@
 
 ### Instalación en Windows
 1. Descarga e instala MultiWorld Utilities desde el enlace anterior, asegurando que instalamos la versión más reciente.
-**El archivo esta localizado en la sección "assets" en la parte inferior de la información de versión**. Si tu intención es jugar la versión normal de multiworld, necesitarás el archivo `Setup.BerserkerMultiWorld.exe`
+**El archivo esta localizado en la sección "assets" en la parte inferior de la información de versión**. Si tu intención es jugar la versión normal de multiworld, necesitarás el archivo `Setup.Archipelago.exe`
     - Si estas interesado en jugar la variante que aleatoriza las puertas internas de las mazmorras, necesitaras bajar 'Setup.BerserkerMultiWorld.Doors.exe'
     - Durante el proceso de instalación, se te pedirá donde esta situado tu archivo ROM japonés v1.0. Si ya habías instalado este software con anterioridad y simplemente estas actualizando, no se te pedirá la localización del archivo una segunda vez.
     - Puede ser que el programa pida la instalación de Microsoft Visual C++. Si ya lo tienes en tu ordenador (posiblemente por que un juego de Steam ya lo haya instalado), el instalador no te pedirá su instalación.
@@ -136,7 +136,7 @@ por unirte satisfactoriamente a una partida de multiworld!
 
 ## Hospedando una partida de multiworld
 La manera recomendad para hospedar una partida es usar el servicio proveído en
-[el sitio web](https://berserkermulti.world/generate). El proceso es relativamente sencillo:
+[el sitio web](/generate). El proceso es relativamente sencillo:
 
 1. Recolecta los ficheros YAML de todos los jugadores que participen.
 2. Crea un fichero ZIP conteniendo esos ficheros.

WebHostLib/static/assets/tutorial/zelda3/multiworld_fr.md

@@ -7,7 +7,7 @@
 </div>
 
 ## Logiciels requis
-- [Utilitaires du MultiWorld](https://github.com/Berserker66/MultiWorld-Utilities/releases)
+- [Archipelago](https://github.com/ArchipelagoMW/Archipelago/releases)
 - [QUsb2Snes](https://github.com/Skarsnik/QUsb2snes/releases) (Inclus dans les utilitaires précédents)
 - Une solution logicielle ou matérielle capable de charger et de lancer des fichiers ROM de SNES
     - Un émulateur capable d'éxécuter des scripts Lua

WebHostLib/static/assets/tutorial/zelda3/plando_en.md

@@ -2,7 +2,7 @@
 
 ## Configuration
 1. Plando features have to be enabled first, before they can be used (opt-in).
-2. To do so, go to your installation directory (Windows default: `C:\ProgramData\BerserkerMultiWorld`), 
+2. To do so, go to your installation directory (Windows default: `C:\ProgramData\Archipelago`), 
    then open the host.yaml file with a text editor.
 3. In it, you're looking for the option key `plando_options`. To enable all plando modules you can set the
    value to  
@@ -13,7 +13,7 @@
 ### Bosses
 
 - This module is enabled by default and available to be used on 
-  [https://archipelago.gg/generate](https://archipelago.gg/generate)
+  [https://archipelago.gg/generate](/generate)
 - Plando versions of boss shuffles can be added like any other boss shuffle option in a yaml and weighted.
 - Boss Plando works as a list of instructions from left to right, if any arenas are empty at the end, 
   it defaults to vanilla

WebHostLib/static/assets/weightedSettings.js

@@ -473,5 +473,11 @@ const generateGame = (raceMode = false) => {
     race: raceMode ? '1' : '0',
   }).then((response) => {
     window.location.href = response.data.url;
+  }).catch((error) => {
+    const userMessage = document.getElementById('user-message');
+    userMessage.innerText = 'Something went wrong and your game could not be generated.';
+    userMessage.classList.add('visible');
+    window.scrollTo(0, 0);
+    console.error(error);
   });
 };

WebHostLib/static/styles/playerSettings.css

@@ -29,6 +29,20 @@ html{
     color: #000000;
 }
 
+#player-settings #user-message{
+    display: none;
+    width: calc(100% - 8px);
+    background-color: #ffe86b;
+    border-radius: 4px;
+    color: #000000;
+    padding: 4px;
+    text-align: center;
+}
+
+#player-settings #user-message.visible{
+    display: block;
+}
+
 #player-settings h1{
     font-size: 2.5rem;
     font-weight: normal;

WebHostLib/static/styles/weightedSettings.css

@@ -14,7 +14,7 @@ html{
     color: #eeffeb;
 }
 
-#user-warning{
+#user-warning, #weighted-settings #user-message{
     display: none;
     width: calc(100% - 8px);
     background-color: #ffe86b;
@@ -25,6 +25,10 @@ html{
     cursor: pointer;
 }
 
+#weighted-settings #user-message.visible{
+    display: block;
+}
+
 #weighted-settings code{
     background-color: #d9cd8e;
     border-radius: 4px;

WebHostLib/templates/autotablepage.html

@@ -1,5 +1,5 @@
 {% extends "tablepage.html" %}
 {% block head %}
     {{ super() }}
-    <script type="application/ecmascript" src="{{ static_autoversion("assets/autodatatable.js") }}"></script>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/autodatatable.js") }}"></script>
 {% endblock %}

WebHostLib/templates/check.html

@@ -3,8 +3,8 @@
 {% block head %}
     {{ super() }}
     <title>Mystery Check Result</title>
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/check.css") }}" />
-    <script type="application/ecmascript" src="{{ static_autoversion("assets/check.js") }}"></script>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/check.css") }}" />
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/check.js") }}"></script>
 {% endblock %}
 
 {% block body %}

WebHostLib/templates/checkResult.html

@@ -3,7 +3,7 @@
 {% block head %}
     {{ super() }}
     <title>Mystery YAML Test Roll Results</title>
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/checkResult.css") }}" />
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/checkResult.css") }}" />
 {% endblock %}
 
 {% block body %}

WebHostLib/templates/generate.html

@@ -3,8 +3,8 @@
 {% block head %}
     {{ super() }}
     <title>Generate Game</title>
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/generate.css") }}" />
-    <script type="application/ecmascript" src="{{ static_autoversion("assets/generate.js") }}"></script>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/generate.css") }}" />
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/generate.js") }}"></script>
 {% endblock %}
 
 {% block body %}
@@ -31,7 +31,7 @@
             <p>
                 After generation is complete, you will have the option to download a patch file.
                 This patch file can be opened with the
-                <a href="https://github.com/Berserker66/MultiWorld-Utilities/releases">client</a>, which can be
+                <a href="https://github.com/ArchipelagoMW/Archipelago/releases">client</a>, which can be
                 used to to create a rom file. In-browser patching is planned for the future.
             </p>
             <div id="generate-game-form-wrapper">

WebHostLib/templates/genericTracker.html

@@ -0,0 +1,63 @@
+{% extends 'tablepage.html' %}
+{% block head %}
+    {{ super() }}
+    <title>{{ player_name }}&apos;s Tracker</title>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/tracker.css") }}"/>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/jquery.scrollsync.js") }}"></script>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/tracker.js") }}"></script>
+{% endblock %}
+
+{% block body %}
+    {% include 'header/dirtHeader.html' %}
+    <div id="tracker-wrapper" data-tracker="{{ room.tracker|suuid }}/{{ team }}/{{ player }}">
+        <div id="tracker-header-bar">
+            <input placeholder="Search" id="search"/>
+            <span class="info">This tracker will automatically update itself periodically.</span>
+        </div>
+            <div class="table-wrapper">
+                <table class="table non-unique-item-table">
+                    <thead>
+                        <tr>
+                            <th>Item</th>
+                            <th>Amount</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+
+                    {% for name, count in inventory.items() %}
+                    <tr>
+                        <td>{{ name | item_name }}</td>
+                        <td>{{ count }}</td>
+                    </tr>
+                    {%- endfor -%}
+
+                    </tbody>
+                </table>
+            </div>
+            <div class="table-wrapper">
+                <table class="table non-unique-item-table">
+                    <thead>
+                    <tr>
+                        <th>Location</th>
+                        <th>Checked</th>
+                    </tr>
+                    </thead>
+                    <tbody>
+                        {% for name in checked_locations %}
+                        <tr>
+                            <td>{{ name | location_name}}</td>
+                            <td>✔</td>
+                        </tr>
+                        {%- endfor -%}
+                        {% for name in not_checked_locations %}
+                        <tr>
+                            <td>{{ name | location_name}}</td>
+                            <td></td>
+                        </tr>
+                        {%- endfor -%}
+                    </tbody>
+                </table>
+            </div>
+        </div>
+    </div>
+{% endblock %}

WebHostLib/templates/header/baseHeader.html

@@ -1,5 +1,5 @@
 {% block head %}
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/header/baseHeader.css") }}" />
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/header/baseHeader.css") }}" />
 {% endblock %}
 
 {% block header %}

WebHostLib/templates/header/dirtHeader.html

@@ -1,5 +1,5 @@
 {% block head %}
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/header/dirtHeader.css") }}" />
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/header/dirtHeader.css") }}" />
 {% endblock %}
 
 {% include 'header/baseHeader.html' %}

WebHostLib/templates/header/grassHeader.html

@@ -1,5 +1,5 @@
 {% block head %}
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/header/grassHeader.css") }}" />
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/header/grassHeader.css") }}" />
 {% endblock %}
 
 {% include 'header/baseHeader.html' %}

WebHostLib/templates/header/oceanHeader.html

@@ -1,5 +1,5 @@
 {% block head %}
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/header/oceanHeader.css") }}" />
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/header/oceanHeader.css") }}" />
 {% endblock %}
 
 {% include 'header/baseHeader.html' %}

WebHostLib/templates/hostGame.html

@@ -3,8 +3,8 @@
 {% block head %}
     {{ super() }}
     <title>Upload Multidata</title>
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/hostGame.css") }}" />
-    <script type="application/ecmascript" src="{{ static_autoversion("assets/hostGame.js") }}"></script>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/hostGame.css") }}" />
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/hostGame.js") }}"></script>
 {% endblock %}
 
 {% block body %}

WebHostLib/templates/hostRoom.html

@@ -2,7 +2,7 @@
 {% import "macros.html" as macros %}
 {% block head %}
     <title>Multiworld {{ room.id|suuid }}</title>
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/hostRoom.css") }}"/>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/hostRoom.css") }}"/>
 {% endblock %}
 
 {% block body %}
@@ -21,7 +21,7 @@
         you can simply refresh this page and the server will be started again.<br>
         {% if room.last_port %}
             You can connect to this room by using '/connect archipelago.gg:{{ room.last_port }}'
-            in the <a href="https://github.com/Berserker66/MultiWorld-Utilities/releases">client</a>.<br>{% endif %}
+            in the <a href="{{ url_for("tutorial_landing")}}">client</a>.<br>{% endif %}
         {{ macros.list_patches_room(room) }}
         {% if room.owner == session["_id"] %}
             <form method=post>

WebHostLib/templates/islandFooter.html

@@ -1,18 +1,18 @@
 {% block footer %}
     <footer id="island-footer">
-        <div id="copyright-notice">Copyright 2020 Archipelago</div>
+        <div id="copyright-notice">Copyright 2021 Archipelago</div>
         <div id="links">
-            <a href="https://github.com/Berserker66/MultiWorld-Utilities">Source Code</a>
+            <a href="https://github.com/ArchipelagoMW/Archipelago">Source Code</a>
             -
-            <a href="https://github.com/Berserker66/MultiWorld-Utilities/wiki">Wiki</a>
+            <a href="https://github.com/ArchipelagoMW/Archipelago/wiki">Wiki</a>
             -
-            <a href="https://github.com/Berserker66/MultiWorld-Utilities/graphs/contributors">Contributors</a>
+            <a href="https://github.com/ArchipelagoMW/Archipelago/graphs/contributors">Contributors</a>
             -
-            <a href="https://github.com/Berserker66/MultiWorld-Utilities/issues">Bug Report</a>
+            <a href="https://github.com/ArchipelagoMW/Archipelago/issues">Bug Report</a>
         </div>
     </footer>
 {% endblock %}
 
 {% block head %}
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/islandFooter.css") }}" />
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/islandFooter.css") }}" />
 {% endblock %}

WebHostLib/templates/landing.html

@@ -2,7 +2,7 @@
 
 {% block head %}
     <title>MultiWorld</title>
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/landing.css") }}" />
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/landing.css") }}" />
 {% endblock %}
 
 {% block body %}
@@ -43,9 +43,9 @@
                     trackers are provided for games hosted here.</p>
                 <p>
                     This project is the cumulative effort of many
-                    <a href="https://github.com/Berserker66/MultiWorld-Utilities/graphs/contributors">talented people.</a>
+                    <a href="https://github.com/ArchipelagoMW/Archipelago/graphs/contributors">talented people.</a>
                     Together, they have spent countless hours creating a huge repository of
-                    <a href="https://github.com/Berserker66/MultiWorld-Utilities">source code</a> which has turned
+                    <a href="https://github.com/ArchipelagoMW/Archipelago">source code</a> which has turned
                     our crazy idea into a reality.
                 </p>
                 <p>

WebHostLib/templates/lttpTracker.html

@@ -2,8 +2,8 @@
 <html lang="en">
 <head>
     <title>{{ player_name }}&apos;s Tracker</title>
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/playerTracker.css") }}"/>
-    <script type="application/ecmascript" src="{{ static_autoversion("assets/playerTracker.js") }}"></script>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/playerTracker.css") }}"/>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/playerTracker.js") }}"></script>
 </head>
 
 <body>
@@ -39,7 +39,7 @@
             </tr>
             <tr>
                 <td><img src="{{ icons["Pegasus Boots"] }}" class="{{ 'acquired' if "Pegasus Boots" in acquired_items }}" /></td>
-                <td><img src="{{ gloves_url }}" class="{{ 'acquired' if gloves_acquired }}" /></td>
+                <td><img src="{{ glove_url }}" class="{{ 'acquired' if glove_acquired }}" /></td>
                 <td><img src="{{ icons["Flippers"] }}" class="{{ 'acquired' if "Flippers" in acquired_items }}" /></td>
                 <td><img src="{{ icons["Moon Pearl"] }}" class="{{ 'acquired' if "Moon Pearl" in acquired_items }}" /></td>
                 <td><img src="{{ icons["Mushroom"] }}" class="{{ 'acquired' if "Mushroom" in acquired_items }}" /></td>

WebHostLib/templates/macros.html

@@ -7,11 +7,19 @@
     </ul>
 {%- endmacro %}
 {% macro list_patches_room(room) %}
-    {% if room.seed.patches %}
+    {% if room.seed.slots %}
         <ul>
-            {% for patch in room.seed.patches|list|sort(attribute="player_id") %}
+            {% for patch in room.seed.slots|list|sort(attribute="player_id") %}
+                {% if patch.game == "Minecraft" %}
+                <li><a href="{{ url_for("download_slot_file", seed_id=room.seed.id, player_id=patch.player_id) }}">
+                    APMC for player {{ patch.player_id }} - {{ patch.player_name }}</a></li>
+                {% elif patch.game == "Factorio" %}
+                <li><a href="{{ url_for("download_slot_file", seed_id=room.seed.id, player_id=patch.player_id) }}">
+                    Mod for player {{ patch.player_id }} - {{ patch.player_name }}</a></li>
+                {% else %}
                 <li><a href="{{ url_for("download_patch", patch_id=patch.id, room_id=room.id) }}">
                     Patch for player {{ patch.player_id }} - {{ patch.player_name }}</a></li>
+                {% endif %}
             {% endfor %}
         </ul>
     {% endif %}

WebHostLib/templates/pageWrapper.html

@@ -4,11 +4,11 @@
     <meta charset="UTF-8">
     <link rel="preconnect" href="https://fonts.gstatic.com">
     <link href="https://fonts.googleapis.com/css2?family=Jost:wght@400;500;600&display=swap" rel="stylesheet">
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/tooltip.css") }}" />
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/cookieNotice.css") }}" />
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/globalStyles.css") }}" />
-    <script type="application/ecmascript" src="{{ static_autoversion("assets/styleController.js") }}"></script>
-    <script type="application/ecmascript" src="{{ static_autoversion("assets/cookieNotice.js") }}"></script>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/tooltip.css") }}" />
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/cookieNotice.css") }}" />
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/globalStyles.css") }}" />
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/styleController.js") }}"></script>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/cookieNotice.js") }}"></script>
     {% block head %}
         <title>MultiWorld</title>
     {% endblock %}

WebHostLib/templates/playerSettings.html

@@ -2,15 +2,16 @@
 
 {% block head %}
     <title>Player Settings</title>
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/playerSettings.css") }}" />
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/playerSettings.css") }}" />
     <script type="application/ecmascript" src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
-    <script type="application/ecmascript" src="{{ static_autoversion("assets/js-yaml.min.js") }}"></script>
-    <script type="application/ecmascript" src="{{ static_autoversion("assets/playerSettings.js") }}"></script>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/js-yaml.min.js") }}"></script>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/playerSettings.js") }}"></script>
 {% endblock %}
 
 {% block body %}
     {% include 'header/grassHeader.html' %}
     <div id="player-settings">
+        <div id="user-message"></div>
         <h1>Start Game</h1>
         <p>Choose the options you would like to play with! You may generate a single-player game from this page,
             or download a settings file you can use to participate in a MultiWorld. If you would like to make

WebHostLib/templates/seedError.html

@@ -3,7 +3,7 @@
 
 {% block head %}
     <title>Generation failed, please retry.</title>
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/waitSeed.css") }}"/>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/waitSeed.css") }}"/>
 {% endblock %}
 
 {% block body %}

WebHostLib/templates/tablepage.html

@@ -7,5 +7,5 @@
     <script type="text/javascript"
             src="https://cdn.datatables.net/v/dt/jq-3.3.1/dt-1.10.21/sc-2.0.2/sp-1.1.1/datatables.min.js"
     ></script>
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/tablepage.css") }}" />
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/tablepage.css") }}" />
 {% endblock %}

WebHostLib/templates/tracker.html

@@ -2,9 +2,9 @@
 {% block head %}
     {{ super() }}
     <title>Multiworld Tracker</title>
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/tracker.css") }}"/>
-    <script type="application/ecmascript" src="{{ static_autoversion("assets/jquery.scrollsync.js") }}"></script>
-    <script type="application/ecmascript" src="{{ static_autoversion("assets/tracker.js") }}"></script>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/tracker.css") }}"/>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/jquery.scrollsync.js") }}"></script>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/tracker.js") }}"></script>
 {% endblock %}
 
 {% block body %}

WebHostLib/templates/tutorial.html

@@ -3,11 +3,11 @@
 {% block head %}
     {% include 'header/grassHeader.html' %}
     <title>Archipelago</title>
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/tutorial.css") }}" />
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/tutorial.css") }}" />
     <script src="https://cdnjs.cloudflare.com/ajax/libs/showdown/1.9.1/showdown.min.js"
             integrity="sha512-L03kznCrNOfVxOUovR6ESfCz9Gfny7gihUX/huVbQB9zjODtYpxaVtIaAkpetoiyV2eqWbvxMH9fiSv5enX7bw=="
             crossorigin="anonymous"></script>
-    <script type="application/ecmascript" src="{{ static_autoversion("assets/tutorial.js") }}"></script>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/tutorial.js") }}"></script>
 {% endblock %}
 
 {% block body %}

WebHostLib/templates/tutorialLanding.html

@@ -3,8 +3,8 @@
 {% block head %}
     {% include 'header/grassHeader.html' %}
     <title>Archipelago Guides</title>
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/tutorialLanding.css") }}" />
-    <script type="application/ecmascript" src="{{ static_autoversion("assets/tutorialLanding.js") }}"></script>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/tutorialLanding.css") }}" />
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/tutorialLanding.js") }}"></script>
 {% endblock %}
 
 {% block body %}

WebHostLib/templates/userContent.html

@@ -3,8 +3,8 @@
 {% block head %}
     {{ super() }}
     <title>Generate Game</title>
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/userContent.css") }}" />
-    <script type="application/ecmascript" src="{{ static_autoversion("assets/userContent.js") }}"></script>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/userContent.css") }}" />
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/userContent.js") }}"></script>
 {% endblock %}
 
 {% block body %}
@@ -31,10 +31,7 @@
                             <tr>
                                 <td><a href="{{ url_for("viewSeed", seed=room.seed.id) }}">{{ room.seed.id|suuid }}</a></td>
                                 <td><a href="{{ url_for("hostRoom", room=room.id) }}">{{ room.id|suuid }}</a></td>
-                                <td
-                                    class="center"
-                                    data-tooltip="{{ room.seed.multidata.names[0]|join(", ")|truncate(256, False, " ...") }}"
-                                >{{ room.seed.multidata.names[0]|length }}</td>
+                                <td>>={{ room.seed.slots|length }}</td>
                                 <td>{{ room.creation_time.strftime("%Y-%m-%d %H:%M") }}</td>
                                 <td>{{ room.last_activity.strftime("%Y-%m-%d %H:%M") }}</td>
                             </tr>
@@ -59,11 +56,7 @@
                         {% for seed in seeds %}
                             <tr>
                                 <td><a href="{{ url_for("viewSeed", seed=seed.id) }}">{{ seed.id|suuid }}</a></td>
-                                <td class="center"
-                                    {% if seed.multidata %}
-                                    data-tooltip="{{ seed.multidata.names[0]|join(", ")|truncate(256, False, " ...") }}"
-                                    {% endif %}
-                                >{% if seed.multidata %}{{ seed.multidata.names[0]|length }}{% else %}1{% endif %}
+                                <td>{% if seed.multidata %}>={{ seed.slots|length }}{% else %}1{% endif %}
                                 </td>
                                 <td>{{ seed.creation_time.strftime("%Y-%m-%d %H:%M") }}</td>
                             </tr>

WebHostLib/templates/viewSeed.html

@@ -3,8 +3,8 @@
 
 {% block head %}
     <title>View Seed {{ seed.id|suuid }}</title>
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/viewSeed.css") }}"/>
-    <script type="application/ecmascript" src="{{ static_autoversion("assets/viewSeed.js") }}"></script>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/viewSeed.css") }}"/>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/viewSeed.js") }}"></script>
 {% endblock %}
 
 {% block body %}
@@ -37,17 +37,10 @@
                         <td>Players:&nbsp;</td>
                         <td>
                             <ul>
-                                {% for team in seed.multidata["names"] %}
-                                    {% set outer_loop = loop %}
-                                    <li>Team #{{ loop.index }} - {{ team | length }}
-                                        <ul>
-                                            {% for player in team %}
-                                                <li>
-                                                    <a href="{{ url_for("download_raw_patch", seed_id=seed.id, player_id=loop.index, team_id=outer_loop.index0) }}">{{ player }}</a>
-                                                </li>
-                                            {% endfor %}
-                                        </ul>
-                                    </li>
+                                {% for patch in seed.slots|sort(attribute='player_id') %}
+                                <li>
+                                    <a href="{{ url_for("download_raw_patch", seed_id=seed.id, player_id=patch.player_id) }}">{{ patch.player_name }}</a>
+                                </li>
                                 {% endfor %}
                             </ul>
                         </td>
@@ -64,13 +57,13 @@
                     </tr>
                 {% else  %}
                 <tr>
-                    <td>Patches:&nbsp;</td>
+                    <td>Files:&nbsp;</td>
                     <td>
                         <ul>
-                            {% for patch in seed.patches %}
+                            {% for slot in seed.slots %}
 
                             <li>
-                                <a href="{{ url_for("download_raw_patch", seed_id=seed.id, player_id=patch.player, team_id=0) }}">Player {{ patch.player }}</a>
+                                <a href="{{ url_for("download_raw_patch", seed_id=seed.id, player_id=slot.player_id) }}">Player {{ slot.player_name }}</a>
                             </li>
 
 

WebHostLib/templates/waitSeed.html

@@ -4,7 +4,7 @@
 {% block head %}
     <title>Generation in Progress</title>
     <meta http-equiv="refresh" content="1">
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/waitSeed.css") }}"/>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/waitSeed.css") }}"/>
 {% endblock %}
 
 {% block body %}

WebHostLib/templates/weightedSettings.html

@@ -2,16 +2,17 @@
 
 {% block head %}
     <title>Player Settings</title>
-    <link rel="stylesheet" type="text/css" href="{{ static_autoversion("styles/weightedSettings.css") }}" />
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/weightedSettings.css") }}" />
     <script type="application/ecmascript" src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
-    <script type="application/ecmascript" src="{{ static_autoversion("assets/js-yaml.min.js") }}"></script>
-    <script type="application/ecmascript" src="{{ static_autoversion("assets/weightedSettings.js") }}"></script>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/js-yaml.min.js") }}"></script>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/weightedSettings.js") }}"></script>
 {% endblock %}
 
 {% block body %}
     {% include 'header/grassHeader.html' %}
     <div id="weighted-settings">
         <header id="user-warning"></header>
+        <div id="user-message"></div>
         <h1>Weighted Settings</h1>
         <div id="instructions">
             This page is used to configure your weighted settings. You have three presets you can control, which

WebHostLib/tracker.py

@@ -5,18 +5,17 @@ from werkzeug.exceptions import abort
 import datetime
 from uuid import UUID
 
-from worlds.alttp import Items, Regions
+from worlds.alttp import Items
 from WebHostLib import app, cache, Room
-from NetUtils import Hint
 from Utils import restricted_loads
+from worlds import lookup_any_item_id_to_name, lookup_any_location_id_to_name
 
-
-def get_id(item_name):
+def get_alttp_id(item_name):
     return Items.item_table[item_name][2]
 
 
-app.jinja_env.filters["location_name"] = lambda location: Regions.lookup_id_to_name.get(location, location)
-app.jinja_env.filters['item_name'] = lambda id: Items.lookup_id_to_name.get(id, id)
+app.jinja_env.filters["location_name"] = lambda location: lookup_any_location_id_to_name.get(location, location)
+app.jinja_env.filters['item_name'] = lambda id: lookup_any_item_id_to_name.get(id, id)
 
 icons = {
     "Blue Shield": r"https://www.zeldadungeon.net/wiki/images/8/85/Fighters-Shield.png",
@@ -155,9 +154,9 @@ levels = {"Fighter Sword": 1,
           "Bow": 1,
           "Silver Bow": 2}
 
-multi_items = {get_id(name) for name in ("Progressive Sword", "Progressive Bow", "Bottle", "Progressive Glove")}
-links = {get_id(key): get_id(value) for key, value in links.items()}
-levels = {get_id(key): value for key, value in levels.items()}
+multi_items = {get_alttp_id(name) for name in ("Progressive Sword", "Progressive Bow", "Bottle", "Progressive Glove")}
+links = {get_alttp_id(key): get_alttp_id(value) for key, value in links.items()}
+levels = {get_alttp_id(key): value for key, value in levels.items()}
 
 tracking_names = ["Progressive Sword", "Progressive Bow", "Book of Mudora", "Hammer",
                   "Hookshot", "Magic Mirror", "Flute",
@@ -237,7 +236,7 @@ ordered_areas = ('Light World', 'Dark World', 'Hyrule Castle', 'Agahnims Tower',
 tracking_ids = []
 
 for item in tracking_names:
-    tracking_ids.append(get_id(item))
+    tracking_ids.append(get_alttp_id(item))
 
 small_key_ids = {}
 big_key_ids = {}
@@ -266,6 +265,7 @@ def attribute_item(inventory, team, recipient, item):
 
 
 def attribute_item_solo(inventory, item):
+    """Adds item to inventory counter, converts everything to progressive."""
     target_item = links.get(item, item)
     if item in levels:  # non-progressive
         inventory[target_item] = max(inventory[target_item], levels[item])
@@ -319,20 +319,22 @@ def get_static_room_data(room: Room):
 
     player_big_key_locations = {playernumber: set() for playernumber in range(1, len(names[0]) + 1)}
     player_small_key_locations = {playernumber: set() for playernumber in range(1, len(names[0]) + 1)}
-    for _, (item_id, item_player) in locations.items():
-        if item_id in ids_big_key:
-            player_big_key_locations[item_player].add(ids_big_key[item_id])
-        if item_id in ids_small_key:
-            player_small_key_locations[item_player].add(ids_small_key[item_id])
+    for loc_data in locations.values():
+        for item_id, item_player in loc_data.values():
+            if item_id in ids_big_key:
+                player_big_key_locations[item_player].add(ids_big_key[item_id])
+            elif item_id in ids_small_key:
+                player_small_key_locations[item_player].add(ids_small_key[item_id])
 
     result = locations, names, use_door_tracker, player_checks_in_area, player_location_to_area, \
-             player_big_key_locations, player_small_key_locations, multidata["precollected_items"]
+             player_big_key_locations, player_small_key_locations, multidata["precollected_items"], \
+             multidata["games"]
     _multidata_cache[room.seed.id] = result
     return result
 
 
 @app.route('/tracker/<suuid:tracker>/<int:tracked_team>/<int:tracked_player>')
-@cache.memoize(timeout=15)
+@cache.memoize(timeout=60)  # multisave is currently created at most every minute
 def getPlayerTracker(tracker: UUID, tracked_team: int, tracked_player: int):
     # Team and player must be positive and greater than zero
     if tracked_team < 0 or tracked_player < 1:
@@ -343,15 +345,15 @@ def getPlayerTracker(tracker: UUID, tracked_team: int, tracked_player: int):
         abort(404)
 
     # Collect seed information and pare it down to a single player
-    locations, names, use_door_tracker, seed_checks_in_area, player_location_to_area, player_big_key_locations, player_small_key_locations, precollected_items = get_static_room_data(room)
+    locations, names, use_door_tracker, seed_checks_in_area, player_location_to_area, \
+    player_big_key_locations, player_small_key_locations, precollected_items, games = get_static_room_data(room)
     player_name = names[tracked_team][tracked_player - 1]
-    seed_checks_in_area = seed_checks_in_area[tracked_player]
     location_to_area = player_location_to_area[tracked_player]
     inventory = collections.Counter()
     checks_done = {loc_name: 0 for loc_name in default_locations}
 
     # Add starting items to inventory
-    starting_items = precollected_items[tracked_player - 1]
+    starting_items = precollected_items[tracked_player]
     if starting_items:
         for item_id in starting_items:
             attribute_item_solo(inventory, item_id)
@@ -362,130 +364,82 @@ def getPlayerTracker(tracker: UUID, tracked_team: int, tracked_player: int):
         multisave = {}
 
     # Add items to player inventory
-    for (ms_team, ms_player), locations_checked in multisave.get("location_checks", {}):
+    for (ms_team, ms_player), locations_checked in multisave.get("location_checks", {}).items():
         # logging.info(f"{ms_team}, {ms_player}, {locations_checked}")
         # Skip teams and players not matching the request
-
+        player_locations = locations[ms_player]
         if ms_team == tracked_team:
             # If the player does not have the item, do nothing
             for location in locations_checked:
-                if (location, ms_player) not in locations:
-                    continue
-
-                item, recipient = locations[location, ms_player]
-                if recipient == tracked_player: # a check done for the tracked player
-                    attribute_item_solo(inventory, item)
-                if ms_player == tracked_player: # a check done by the tracked player
-                    checks_done[location_to_area[location]] += 1
-                    checks_done["Total"] += 1
-
-    # Note the presence of the triforce item
-    for (ms_team, ms_player), game_state in multisave.get("client_game_state", []):
-        # Skip teams and players not matching the request
-        if ms_team != tracked_team or ms_player != tracked_player:
-            continue
-
-        if game_state:
+                if location in player_locations:
+                    item, recipient = player_locations[location]
+                    if recipient == tracked_player: # a check done for the tracked player
+                        attribute_item_solo(inventory, item)
+                    if ms_player == tracked_player: # a check done by the tracked player
+                        checks_done[location_to_area[location]] += 1
+                        checks_done["Total"] += 1
+    if games[tracked_player] == "A Link to the Past":
+        # Note the presence of the triforce item
+        game_state = multisave.get("client_game_state", {}).get((tracked_team, tracked_player), 0)
+        if game_state == 30:
             inventory[106] = 1  # Triforce
 
-    acquired_items = []
-    for itm in inventory:
-        acquired_items.append(get_item_name_from_id(itm))
+        # Progressive items need special handling for icons and class
+        progressive_items = {
+            "Progressive Sword": 94,
+            "Progressive Glove": 97,
+            "Progressive Bow": 100,
+            "Progressive Mail": 96,
+            "Progressive Shield": 95,
+        }
+        progressive_names = {
+            "Progressive Sword": [None, 'Fighter Sword', 'Master Sword', 'Tempered Sword', 'Golden Sword'],
+            "Progressive Glove": [None, 'Power Glove', 'Titan Mitts'],
+            "Progressive Bow": [None, "Bow", "Silver Bow"],
+            "Progressive Mail": ["Green Mail", "Blue Mail", "Red Mail"],
+            "Progressive Shield": [None, "Blue Shield", "Red Shield", "Mirror Shield"]
+        }
 
-    # Progressive items need special handling for icons and class
-    progressive_items = {
-        "Progressive Sword": 94,
-        "Progressive Glove": 97,
-        "Progressive Bow": 100,
-        "Progressive Mail": 96,
-        "Progressive Shield": 95,
-    }
+        # Determine which icon to use
+        display_data = {}
+        for item_name, item_id in progressive_items.items():
+            level = min(inventory[item_id], len(progressive_names[item_name])-1)
+            display_name = progressive_names[item_name][level]
+            acquired = True
+            if not display_name:
+                acquired = False
+                display_name = progressive_names[item_name][level+1]
+            base_name = item_name.split(maxsplit=1)[1].lower()
+            display_data[base_name+"_acquired"] = acquired
+            display_data[base_name+"_url"] = icons[display_name]
 
-    # Determine which icon to use for the sword
-    sword_url = icons["Fighter Sword"]
-    sword_acquired = False
-    sword_names = ['Fighter Sword', 'Master Sword', 'Tempered Sword', 'Golden Sword']
-    if "Progressive Sword" in acquired_items:
-        sword_url = icons[sword_names[min(inventory[progressive_items["Progressive Sword"]], 4) - 1]]
-        sword_acquired = True
+
+        # The single player tracker doesn't care about overworld, underworld, and total checks. Maybe it should?
+        sp_areas = ordered_areas[2:15]
+
+        return render_template("lttpTracker.html", inventory=inventory,
+                               player_name=player_name, room=room, icons=icons, checks_done=checks_done,
+                               checks_in_area=seed_checks_in_area[tracked_player], acquired_items={lookup_any_item_id_to_name[id] for id in inventory},
+                               small_key_ids=small_key_ids, big_key_ids=big_key_ids, sp_areas=sp_areas,
+                               key_locations=player_small_key_locations[tracked_player],
+                               big_key_locations=player_big_key_locations[tracked_player],
+                               **display_data)
     else:
-        for sword in reversed(sword_names):
-            if sword in acquired_items:
-                sword_url = icons[sword]
-                sword_acquired = True
-                break
-
-    gloves_url = icons["Power Glove"]
-    gloves_acquired = False
-    glove_names = ["Power Glove", "Titan Mitts"]
-    if "Progressive Glove" in acquired_items:
-        gloves_url = icons[glove_names[min(inventory[progressive_items["Progressive Glove"]], 2) - 1]]
-        gloves_acquired = True
-    else:
-        for glove in reversed(glove_names):
-            if glove in acquired_items:
-                gloves_url = icons[glove]
-                gloves_acquired = True
-                break
-
-    bow_url = icons["Bow"]
-    bow_acquired = False
-    bow_names = ["Bow", "Silver Bow"]
-    if "Progressive Bow" in acquired_items:
-        bow_url = icons[bow_names[min(inventory[progressive_items["Progressive Bow"]], 2) - 1]]
-        bow_acquired = True
-    else:
-        for bow in reversed(bow_names):
-            if bow in acquired_items:
-                bow_url = icons[bow]
-                bow_acquired = True
-                break
-
-    mail_url = icons["Green Mail"]
-    mail_names = ["Blue Mail", "Red Mail"]
-    if "Progressive Mail" in acquired_items:
-        mail_url = icons[mail_names[min(inventory[progressive_items["Progressive Mail"]], 2) - 1]]
-    else:
-        for mail in reversed(mail_names):
-            if mail in acquired_items:
-                mail_url = icons[mail]
-                break
-
-    shield_url = icons["Blue Shield"]
-    shield_acquired = False
-    shield_names = ["Blue Shield", "Red Shield", "Mirror Shield"]
-    if "Progressive Shield" in acquired_items:
-        shield_url = icons[shield_names[min(inventory[progressive_items["Progressive Shield"]], 3) - 1]]
-        shield_acquired = True
-    else:
-        for shield in reversed(shield_names):
-            if shield in acquired_items:
-                shield_url = icons[shield]
-                shield_acquired = True
-                break
-
-    # The single player tracker doesn't care about overworld, underworld, and total checks. Maybe it should?
-    sp_areas = ordered_areas[2:15]
-
-    return render_template("playerTracker.html", inventory=inventory, get_item_name_from_id=get_item_name_from_id,
-                           player_name=player_name, room=room, icons=icons, checks_done=checks_done,
-                           checks_in_area=seed_checks_in_area, acquired_items=acquired_items,
-                           sword_url=sword_url, sword_acquired=sword_acquired, gloves_url=gloves_url,
-                           gloves_acquired=gloves_acquired, bow_url=bow_url, bow_acquired=bow_acquired,
-                           small_key_ids=small_key_ids, big_key_ids=big_key_ids, sp_areas=sp_areas,
-                           key_locations=player_small_key_locations[tracked_player],
-                           big_key_locations=player_big_key_locations[tracked_player],
-                           mail_url=mail_url, shield_url=shield_url, shield_acquired=shield_acquired)
+        checked_locations = multisave.get("location_checks", {}).get((tracked_team, tracked_player), set())
+        return render_template("genericTracker.html",
+                               inventory=inventory,
+                               player=tracked_player, team=tracked_team, room=room, player_name=player_name,
+                               checked_locations= checked_locations, not_checked_locations = set(locations[tracked_player])-checked_locations)
 
 
 @app.route('/tracker/<suuid:tracker>')
-@cache.memoize(timeout=30)  # update every 30 seconds
+@cache.memoize(timeout=60)  # multisave is currently created at most every minute
 def getTracker(tracker: UUID):
     room = Room.get(tracker=tracker)
     if not room:
         abort(404)
     locations, names, use_door_tracker, seed_checks_in_area, player_location_to_area, player_big_key_locations, \
-    player_small_key_locations, precollected_items = get_static_room_data(room)
+    player_small_key_locations, precollected_items, games = get_static_room_data(room)
 
     inventory = {teamnumber: {playernumber: collections.Counter() for playernumber in range(1, len(team) + 1)}
                  for teamnumber, team in enumerate(names)}
@@ -500,26 +454,26 @@ def getTracker(tracker: UUID):
     else:
         multisave = {}
     if "hints" in multisave:
-        for key, hintdata in multisave["hints"]:
-            for hint in hintdata:
-                hints[key[0]].add(Hint(*hint))
+        for (team, slot), slot_hints in multisave["hints"].items():
+            hints[team] |= set(slot_hints)
 
-    for (team, player), locations_checked in multisave.get("location_checks", {}):
+    for (team, player), locations_checked in multisave.get("location_checks", {}).items():
+        player_locations = locations[player]
         if precollected_items:
-            precollected = precollected_items[player - 1]
+            precollected = precollected_items[player]
             for item_id in precollected:
                 attribute_item(inventory, team, player, item_id)
         for location in locations_checked:
-            if (location, player) not in locations or location not in player_location_to_area[player]:
+            if location not in player_locations or location not in player_location_to_area[player]:
                 continue
 
-            item, recipient = locations[location, player]
+            item, recipient = player_locations[location]
             attribute_item(inventory, team, recipient, item)
             checks_done[team][player][player_location_to_area[player][location]] += 1
             checks_done[team][player]["Total"] += 1
 
-    for (team, player), game_state in multisave.get("client_game_state", []):
-        if game_state:
+    for (team, player), game_state in multisave.get("client_game_state", {}).items():
+        if game_state == 30:
             inventory[team][player][106] = 1  # Triforce
 
     group_big_key_locations = set()
@@ -538,7 +492,7 @@ def getTracker(tracker: UUID):
         for player, name in enumerate(names, 1):
             player_names[(team, player)] = name
     long_player_names = player_names.copy()
-    for (team, player), alias in multisave.get("name_aliases", []):
+    for (team, player), alias in multisave.get("name_aliases", {}).items():
         player_names[(team, player)] = alias
         long_player_names[(team, player)] = f"{alias} ({long_player_names[(team, player)]})"
 

WebHostLib/upload.py

@@ -1,13 +1,14 @@
-import json
-import zlib
 import zipfile
-import logging
+import lzma
+import json
+import base64
 import MultiServer
 
 from flask import request, flash, redirect, url_for, session, render_template
-from pony.orm import commit, select
+from pony.orm import flush, select
 
-from WebHostLib import app, Seed, Room, Patch
+from WebHostLib import app, Seed, Room, Slot
+from Utils import parse_yaml
 
 accepted_zip_contents = {"patches": ".apbp",
                          "spoiler": ".txt",
@@ -30,7 +31,7 @@ def uploads():
                 flash('No selected file')
             elif file and allowed_file(file.filename):
                 if file.filename.endswith(".zip"):
-                    patches = set()
+                    slots = set()
                     spoiler = ""
                     multidata = None
                     with zipfile.ZipFile(file, 'r') as zfile:
@@ -40,9 +41,28 @@ def uploads():
                             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(".apbp"):
-                                splitted = file.filename.split("/")[-1][3:].split("P", 1)
-                                player_id, player_name = splitted[1].split(".")[0].split("_")
-                                patches.add(Patch(data=zfile.open(file, "r").read(), player_name=player_name, player_id=player_id))
+                                data = zfile.open(file, "r").read()
+                                yaml_data = parse_yaml(lzma.decompress(data).decode("utf-8-sig"))
+                                if yaml_data["version"] < 2:
+                                    return "Old format cannot be uploaded (outdated .apbp)", 500
+                                metadata = yaml_data["meta"]
+                                slots.add(Slot(data=data, player_name=metadata["player_name"],
+                                               player_id=metadata["player_id"],
+                                               game="A Link to the Past"))
+
+                            elif file.filename.endswith(".apmc"):
+                                data = zfile.open(file, "r").read()
+                                metadata = json.loads(base64.b64decode(data).decode("utf-8"))
+                                slots.add(Slot(data=data, player_name=metadata["player_name"],
+                                               player_id=metadata["player_id"],
+                                               game="Minecraft"))
+
+                            elif file.filename.endswith(".zip"):
+                                # Factorio mods needs a specific name or they do no function
+                                _, seed_name, slot_id, slot_name = file.filename.rsplit("_", 1)[0].split("-")
+                                slots.add(Slot(data=zfile.open(file, "r").read(), player_name=slot_name,
+                                              player_id=int(slot_id[1:]), game="Factorio"))
+
                             elif file.filename.endswith(".txt"):
                                 spoiler = zfile.open(file, "r").read().decode("utf-8-sig")
                             elif file.filename.endswith(".archipelago"):
@@ -54,11 +74,11 @@ def uploads():
                                 else:
                                     multidata = zfile.open(file).read()
                         if multidata:
-                            commit()  # commit patches
-                            seed = Seed(multidata=multidata, spoiler=spoiler, patches=patches, owner=session["_id"])
-                            commit()  # create seed
-                            for patch in patches:
-                                patch.seed = seed
+                            flush()  # commit slots
+                            seed = Seed(multidata=multidata, spoiler=spoiler, slots=slots, owner=session["_id"])
+                            flush()  # create seed
+                            for slot in slots:
+                                slot.seed = seed
 
                             return redirect(url_for("viewSeed", seed=seed.id))
                         else:
@@ -72,7 +92,7 @@ def uploads():
                         raise
                     else:
                         seed = Seed(multidata=multidata, owner=session["_id"])
-                        commit()  # place into DB and generate ids
+                        flush()  # place into DB and generate ids
                         return redirect(url_for("viewSeed", seed=seed.id))
             else:
                 flash("Not recognized file format. Awaiting a .multidata file.")

WebUI.py

@@ -1,159 +0,0 @@
-import http.server
-import logging
-import json
-import typing
-import socket
-import socketserver
-import threading
-import webbrowser
-import asyncio
-from functools import partial
-
-from NetUtils import Node
-from LttPClient import Context
-import Utils
-
-
-class WebUiClient(Node, logging.Handler):
-    loader = staticmethod(json.loads)
-    dumper = staticmethod(json.dumps)
-    def __init__(self):
-        super(WebUiClient, self).__init__()
-        self.manual_snes = None
-
-    @staticmethod
-    def build_message(msg_type: str, content: typing.Union[str, dict]) -> dict:
-        return {'type': msg_type, 'content': content}
-
-    def emit(self, record: logging.LogRecord) -> None:
-        self.broadcast_all({"type": record.levelname.lower(), "content": str(record.msg)})
-
-    def send_chat_message(self, message):
-        self.broadcast_all(self.build_message('chat', message))
-
-    def send_connection_status(self, ctx: Context):
-        asyncio.create_task(self._send_connection_status(ctx))
-
-    async def _send_connection_status(self, ctx: Context):
-        cache = Utils.persistent_load()
-        cached_address = cache.get("servers", {}).get("default", None)
-        server_address = ctx.server_address if ctx.server_address else cached_address if cached_address else None
-
-        self.broadcast_all(self.build_message('connections', {
-            'snesDevice': ctx.snes_attached_device[1] if ctx.snes_attached_device else None,
-            'snes': ctx.snes_state,
-            'serverAddress': server_address,
-            'server': 1 if ctx.server is not None and not ctx.server.socket.closed else 0,
-        }))
-
-    def send_device_list(self, devices):
-        self.broadcast_all(self.build_message('availableDevices', {
-            'devices': devices,
-        }))
-
-    def poll_for_server_ip(self):
-        self.broadcast_all(self.build_message('serverAddress', {}))
-
-    def notify_item_sent(self, finder, recipient, item, location, i_am_finder: bool, i_am_recipient: bool,
-                         item_is_unique: bool = False):
-        self.broadcast_all(self.build_message('itemSent', {
-            'finder': finder,
-            'recipient': recipient,
-            'item': item,
-            'location': location,
-            'iAmFinder': int(i_am_finder),
-            'iAmRecipient': int(i_am_recipient),
-            'itemIsUnique': int(item_is_unique),
-        }))
-
-    def notify_item_found(self, finder: str, item: str, location: str, i_am_finder: bool, item_is_unique: bool = False):
-        self.broadcast_all(self.build_message('itemFound', {
-            'finder': finder,
-            'item': item,
-            'location': location,
-            'iAmFinder': int(i_am_finder),
-            'itemIsUnique': int(item_is_unique),
-        }))
-
-    def notify_item_received(self, finder: str, item: str, location: str, item_index: int, queue_length: int,
-                             item_is_unique: bool = False):
-        self.broadcast_all(self.build_message('itemReceived', {
-            'finder': finder,
-            'item': item,
-            'location': location,
-            'itemIndex': item_index,
-            'queueLength': queue_length,
-            'itemIsUnique': int(item_is_unique),
-        }))
-
-    def send_hint(self, finder, recipient, item, location, found, i_am_finder: bool, i_am_recipient: bool,
-                  entrance_location: str = None):
-        self.broadcast_all(self.build_message('hint', {
-            'finder': finder,
-            'recipient': recipient,
-            'item': item,
-            'location': location,
-            'found': int(found),
-            'iAmFinder': int(i_am_finder),
-            'iAmRecipient': int(i_am_recipient),
-            'entranceLocation': entrance_location,
-        }))
-
-    def send_game_info(self, ctx: Context):
-        self.broadcast_all(self.build_message('gameInfo', {
-            'clientVersion': Utils.__version__,
-            'hintCost': ctx.hint_cost,
-            'checkPoints': ctx.check_points,
-            'forfeitMode': ctx.forfeit_mode,
-            'remainingMode': ctx.remaining_mode,
-        }))
-
-    def send_location_check(self, ctx: Context, last_check: str):
-        self.broadcast_all(self.build_message('locationCheck', {
-            'totalChecks': len(ctx.locations_checked),
-            'hintPoints': ctx.hint_points,
-            'lastCheck': last_check,
-        }))
-
-
-web_thread = None
-PORT = 5050
-
-
-class RequestHandler(http.server.SimpleHTTPRequestHandler):
-    def log_request(self, code='-', size='-'):
-        pass
-
-    def log_message(self, format, *args):
-        pass
-
-    def log_date_time_string(self):
-        pass
-
-
-Handler = partial(RequestHandler,
-                  directory=Utils.local_path("data", "web", "public"))
-
-
-def start_server(socket_port: int, on_start=lambda: None):
-    global web_thread
-    try:
-        server = socketserver.TCPServer(("", PORT), Handler)
-    except OSError:
-        # In most cases "Only one usage of each socket address (protocol/network address/port) is normally permitted"
-        import logging
-
-        # If the exception is caused by our desired port being unavailable, assume the web server is already running
-        # from another client instance
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-            if sock.connect_ex(('localhost', PORT)) == 0:
-                logging.info("Web server is already running in another client window.")
-                webbrowser.open(f'http://localhost:{PORT}?port={socket_port}')
-                return
-
-        # If the exception is caused by something else, report on it
-        logging.exception("Unable to bind port for local web server. The CLI client should work in all cases.")
-    else:
-        print("serving at port", PORT)
-        on_start()
-        web_thread = threading.Thread(target=server.serve_forever).start()

data/default.apsprite

@@ -0,0 +1,7 @@
+author: Nintendo
+data: null
+game: A Link to the Past
+min_format_version: 1
+name: Link
+format_version: 1
+sprite_version: 1

data/factorio/machines.json

@@ -0,0 +1 @@
+{"stone-furnace":{"smelting":true},"steel-furnace":{"smelting":true},"electric-furnace":{"smelting":true},"assembling-machine-1":{"crafting":true,"basic-crafting":true,"advanced-crafting":true},"assembling-machine-2":{"basic-crafting":true,"crafting":true,"advanced-crafting":true,"crafting-with-fluid":true},"assembling-machine-3":{"basic-crafting":true,"crafting":true,"advanced-crafting":true,"crafting-with-fluid":true},"oil-refinery":{"oil-processing":true},"chemical-plant":{"chemistry":true},"centrifuge":{"centrifuging":true},"rocket-silo":{"rocket-building":true},"character":{"crafting":true}}

data/factorio/mod/LICENSE.md

@@ -1,7 +1,7 @@
 
 The MIT License (MIT)
 
-Copyright (c) 2021 Berserker55
+Copyright (c) 2021 Berserker55 and Dewiniaid
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/factorio/mod/info.json

@@ -2,7 +2,7 @@
     "name": "archipelago-client",
     "version": "0.0.1",
     "title": "Archipelago",
-    "author": "Berserker",
+    "author": "Berserker and Dewiniaid",
     "homepage": "https://archipelago.gg",
     "description": "Integration client for the Archipelago Randomizer",
     "factorio_version": "1.1"

data/factorio/mod/lib.lua

@@ -1,7 +1,7 @@
-function filter_ingredients(ingredients)
+function filter_ingredients(ingredients, ingredient_filter)
     local new_ingredient_list = {}
     for _, ingredient_table in pairs(ingredients) do
-        if allowed_ingredients[ingredient_table[1]] then -- name of ingredient_table
+        if ingredient_filter[ingredient_table[1]] then -- name of ingredient_table
             table.insert(new_ingredient_list, ingredient_table)
         end
     end

data/factorio/mod_template/control.lua

@@ -1,131 +1,235 @@
+{% from "macros.lua" import dict_to_lua %}
+-- this file gets written automatically by the Archipelago Randomizer and is in its raw form a Jinja2 Template
 require "lib"
--- for testing
-script.on_event(defines.events.on_tick, function(event)
-    if event.tick%600 == 0 then
-        dumpTech(game.forces["player"])
+require "util"
+
+FREE_SAMPLES = {{ free_samples }}
+SLOT_NAME = "{{ slot_name }}"
+SEED_NAME = "{{ seed_name }}"
+--SUPPRESS_INVENTORY_EVENTS = false
+
+-- Initialize force data, either from it being created or already being part of the game when the mod was added.
+function on_force_created(event)
+    --event.force appears to be LuaForce.name, not LuaForce
+    game.forces[event.force].research_queue_enabled = true
+    local data = {}
+    data['earned_samples'] = {{ dict_to_lua(starting_items) }}
+    data["victory"] = 0
+    global.forcedata[event.force] = data
+end
+script.on_event(defines.events.on_force_created, on_force_created)
+
+-- Destroy force data.  This doesn't appear to be currently possible with the Factorio API, but here for completeness.
+function on_force_destroyed(event)
+    global.forcedata[event.force.name] = nil
+end
+
+-- Initialize player data, either from them joining the game or them already being part of the game when the mod was
+-- added.`
+function on_player_created(event)
+    local player = game.players[event.player_index]
+    -- FIXME: This (probably) fires before any other mod has a chance to change the player's force
+    -- For now, they will (probably) always be on the 'player' force when this event fires.
+    local data = {}
+    data['pending_samples'] = table.deepcopy(global.forcedata[player.force.name]['earned_samples'])
+    global.playerdata[player.index] = data
+    update_player(player.index)  -- Attempt to send pending free samples, if relevant.
+end
+script.on_event(defines.events.on_player_created, on_player_created)
+
+function on_player_removed(event)
+    global.playerdata[event.player_index] = nil
+end
+script.on_event(defines.events.on_player_removed, on_player_removed)
+
+function on_rocket_launched(event)
+    global.forcedata[event.rocket.force.name]['victory'] = 1
+    dumpInfo(event.rocket.force)
+end
+script.on_event(defines.events.on_rocket_launched, on_rocket_launched)
+
+-- Updates a player, attempting to send them any pending samples (if relevant)
+function update_player(index)
+    local player = game.players[index]
+    if not player or not player.valid then     -- Do nothing if we reference an invalid player somehow
+        return
+    end
+    local character = player.character or player.cutscene_character
+    if not character or not character.valid then
+        return
+    end
+    local data = global.playerdata[index]
+    local samples = data['pending_samples']
+    local sent
+    --player.print(serpent.block(data['pending_samples']))
+    local stack = {}
+    --SUPPRESS_INVENTORY_EVENTS = true
+    for name, count in pairs(samples) do
+        stack.name = name
+        stack.count = count
+        if character.can_insert(stack) then
+            sent = character.insert(stack)
+        else
+            sent = 0
+        end
+        if sent > 0 then
+            player.print("Received " .. sent .. "x [item=" .. name .. "]")
+            data.suppress_full_inventory_message = false
+        end
+        if sent ~= count then               -- Couldn't full send.
+            if not data.suppress_full_inventory_message then
+                player.print("Additional items will be sent when inventory space is available.", {r=1, g=1, b=0.25})
+            end
+            data.suppress_full_inventory_message = true -- Avoid spamming them with repeated full inventory messages.
+            samples[name] = count - sent    -- Buffer the remaining items
+            break                           -- Stop trying to send other things
+        else
+            samples[name] = nil             -- Remove from the list
+        end
+    end
+    --SUPPRESS_INVENTORY_EVENTS = false
+end
+
+-- Update players upon them connecting, since updates while they're offline are suppressed.
+script.on_event(defines.events.on_player_joined_game, function(event) update_player(event.player_index) end)
+
+function update_player_event(event)
+    --if not SUPPRESS_INVENTORY_EVENTS then
+    update_player(event.player_index)
+    --end
+end
+
+script.on_event(defines.events.on_player_main_inventory_changed, update_player_event)
+
+function add_samples(force, name, count)
+    local function add_to_table(t)
+        t[name] = (t[name] or 0) + count
+    end
+    -- Add to global table of earned samples for future new players
+    add_to_table(global.forcedata[force.name]['earned_samples'])
+    -- Add to existing players
+    for _, player in pairs(force.players) do
+        add_to_table(global.playerdata[player.index]['pending_samples'])
+        update_player(player.index)
+    end
+end
+
+script.on_init(function()
+    global.forcedata = {}
+    global.playerdata = {}
+    -- Fire dummy events for all currently existing forces.
+    local e = {}
+    for name, _ in pairs(game.forces) do
+        e.force = name
+        on_force_created(e)
+    end
+    e.force = nil
+
+    -- Fire dummy events for all currently existing players.
+    for index, _ in pairs(game.players) do
+        e.player_index = index
+        on_player_created(e)
     end
 end)
 
+-- for testing
+-- script.on_event(defines.events.on_tick, function(event)
+--     if event.tick%3600 == 300 then
+--         dumpInfo(game.forces["player"])
+--     end
+-- end)
+
 -- hook into researches done
 script.on_event(defines.events.on_research_finished, function(event)
     local technology = event.research
-    dumpTech(technology.force)
-    {% if free_samples %}
-    local players = technology.force.players
-    if technology.effects then
-        for _, effect in pairs(technology.effects) do
-            if effect.type == "unlock-recipe" then
-                local recipe = game.recipe_prototypes[effect.recipe]
-                for _, result in pairs(recipe.products) do
-                    if result.type == "item" and result.amount then
-                        {% if free_samples == 1 %}
-                        local new = {count=result.amount, name=result.name}
-                        {% elif free_samples == 2 %}
-                        local new = {count=get_any_stack_size(result.name) * 0.5, name=result.name}
-                        {% else %}
-                        local new = {count=get_any_stack_size(result.name), name=result.name}
-                        {% endif %}
-                        for _, player in pairs(players) do
-                            player.insert(new)
+    if technology.researched and string.find(technology.name, "ap%-") == 1 then
+        dumpInfo(technology.force) --is sendable
+    end
+    if FREE_SAMPLES == 0 then
+        return  -- Nothing else to do
+    end
+    if not technology.effects then
+        return  -- No technology effects, so nothing to do.
+    end
+    for _, effect in pairs(technology.effects) do
+        if effect.type == "unlock-recipe" then
+            local recipe = game.recipe_prototypes[effect.recipe]
+            for _, result in pairs(recipe.products) do
+                if result.type == "item" and result.amount then
+                    local name = result.name
+                    local count
+                    if FREE_SAMPLES == 1 then
+                        count = result.amount
+                    else
+                        count = get_any_stack_size(result.name)
+                        if FREE_SAMPLES == 2 then
+                            count = math.ceil(count / 2)
                         end
                     end
+                    add_samples(technology.force, name, count)
                 end
             end
         end
     end
-    {% endif %}
-
 end)
 
-function dumpTech(force)
-    local data_collection = {}
+function dumpInfo(force)
+    local research_done = {}
+    local data_collection = {
+        ["research_done"] = research_done,
+        ["victory"] = chain_lookup(global, "forcedata", force.name, "victory"),
+        ["slot_name"] = SLOT_NAME,
+        ["seed_name"] = SEED_NAME
+        }
+
     for tech_name, tech in pairs(force.technologies) do
-        if tech.researched and string.find(tech_name, "ap-") == 1 then
-            data_collection[tech_name] = tech.researched
+        if tech.researched and string.find(tech_name, "ap%-") == 1 then
+            research_done[tech_name] = tech.researched
         end
     end
-    game.write_file("research_done.json", game.table_to_json(data_collection), false)
+    game.write_file("ap_bridge.json", game.table_to_json(data_collection), false, 0)
+    log("Archipelago Bridge File written for game tick ".. game.tick .. ".")
     -- game.write_file("research_done.json", game.table_to_json(data_collection), false, 0)
     -- game.print("Sent progress to Archipelago.")
 end
 
-function dumpGameInfo()
-    -- dump Game Information that the Archipelago Randomizer needs.
-    local data_collection = {}
-    local force = game.forces["player"]
-    for tech_name, tech in pairs(force.technologies) do
-        if tech.enabled and tech.research_unit_count_formula == nil then
-            local tech_data = {}
-            local unlocks = {}
-            tech_data["unlocks"] = unlocks
-            local requires = {}
-            tech_data["requires"] = requires
-            local ingredients = {}
-            tech_data["ingredients"] = ingredients
-            for tech_requirement, _ in pairs(tech.prerequisites) do
-                table.insert(requires, tech_requirement)
-            end
-            for _, modifier in pairs(tech.effects) do
-                if modifier.type == "unlock-recipe" then
-                    table.insert(unlocks, modifier.recipe)
-                end
-            end
-            for _, ingredient in pairs(tech.research_unit_ingredients) do
-                table.insert(ingredients, ingredient.name)
-            end
-            data_collection[tech_name] = tech_data
 
+
+function chain_lookup(table, ...)
+    for _, k in ipairs{...} do
+        table = table[k]
+        if not table then
+            return nil
         end
-        game.write_file("techs.json", game.table_to_json(data_collection), false)
-        game.print("Exported Tech Data")
     end
-    data_collection = {}
-    for recipe_name, recipe in pairs(force.recipes) do
-        local recipe_data = {}
-        recipe_data["ingredients"] = {}
-        recipe_data["products"] = {}
-        recipe_data["category"] = recipe.category
-        for _, ingredient in pairs(recipe.ingredients) do
-            table.insert(recipe_data["ingredients"], ingredient.name)
-        end
-        for _, product in pairs(recipe.products) do
-            table.insert(recipe_data["products"], product.name)
-        end
-        data_collection[recipe_name] = recipe_data
-    end
-    game.write_file("recipes.json", game.table_to_json(data_collection), false)
-    game.print("Exported Recipe Data")
-    -- data.raw can't be accessed from control.lua, need to find a better method
-    -- data_collection = {}
-    -- for machine_name, machine in pairs(data.raw["assembling_machine"]) do
-    --     local machine_data = {}
-    --     machine_data["categories"] = table.deepcopy(machine.crafting_categories)
-    --     data_collection[machine.name] = machine_data
-    -- end
-    -- game.write_file("machines.json", game.table_to_json(data_collection), false)
-    -- game.print("Exported Machine Data")
+    return table
 end
 
 -- add / commands
 
-commands.add_command("ap-get-info-dump", "Dump Game Info, used by Archipelago.", function(call)
-    dumpGameInfo()
-end)
-
 commands.add_command("ap-sync", "Run manual Research Sync with Archipelago.", function(call)
-    dumpTech(game.players[call.player_index].force)
+    if call.player_index == nil then
+        dumpInfo(game.forces.player)
+    else
+        dumpInfo(game.players[call.player_index].force)
+    end
     game.print("Wrote bridge file.")
 end)
 
 commands.add_command("ap-get-technology", "Grant a technology, used by the Archipelago Client.", function(call)
     local force = game.forces["player"]
-    local tech_name = call.parameter
+    chunks = {}
+    for substring in call.parameter:gmatch("%S+") do -- split on " "
+        table.insert(chunks, substring)
+    end
+    local tech_name = chunks[1]
+    local source = chunks[2] or "Archipelago"
     local tech = force.technologies[tech_name]
     if tech ~= nil then
         if tech.researched ~= true then
-            tech.researched = true
-            game.print({"", "Received ", tech.localised_name, " from Archipelago"})
+            game.print({"", "Received [technology=" .. tech.name .. "] from ", source})
             game.play_sound({path="utility/research_completed"})
+            tech.researched = true
         end
     else
         game.print("Unknown Technology " .. tech_name)

data/factorio/mod_template/data-final-fixes.lua

@@ -1,12 +1,19 @@
+{% from "macros.lua" import dict_to_recipe %}
 -- this file gets written automatically by the Archipelago Randomizer and is in its raw form a Jinja2 Template
 require('lib')
 
+data.raw["recipe"]["rocket-part"].ingredients = {{ dict_to_recipe(rocket_recipe) }}
+
 local technologies = data.raw["technology"]
 local original_tech
 local new_tree_copy
 allowed_ingredients = {}
-{%- for ingredient in allowed_science_packs %}
-allowed_ingredients["{{ingredient}}"]= 1
+{%- for tech_name, technology in custom_data["custom_technologies"].items() %}
+allowed_ingredients["{{ tech_name }}"] = {
+{%- for ingredient in technology.ingredients %}
+["{{ingredient}}"] = 1,
+{%- endfor %}
+}
 {% endfor %}
 local template_tech = table.deepcopy(technologies["automation"])
 {#-  ensure the copy unlocks nothing #}
@@ -18,33 +25,57 @@ template_tech.prerequisites = {}
 function prep_copy(new_copy, old_tech)
     old_tech.enabled = false
     new_copy.unit = table.deepcopy(old_tech.unit)
-    new_copy.unit.ingredients = filter_ingredients(new_copy.unit.ingredients)
+    local ingredient_filter = allowed_ingredients[old_tech.name]
+    if ingredient_filter ~= nil then
+        new_copy.unit.ingredients = filter_ingredients(new_copy.unit.ingredients, ingredient_filter)
+    end
 end
 
+function set_ap_icon(tech)
+    tech.icon = "__{{ mod_name }}__/graphics/icons/ap.png"
+    tech.icons = nil
+    tech.icon_size = 128
+end
+
+function set_ap_unimportant_icon(tech)
+    tech.icon = "__{{ mod_name }}__/graphics/icons/ap_unimportant.png"
+    tech.icons = nil
+    tech.icon_size = 128
+end
+
+function copy_factorio_icon(tech, tech_source)
+    tech.icon = table.deepcopy(technologies[tech_source].icon)
+    tech.icons = table.deepcopy(technologies[tech_source].icons)
+    tech.icon_size = table.deepcopy(technologies[tech_source].icon_size)
+end
+
+function adjust_energy(recipe_name, factor)
+    local energy = data.raw.recipe[recipe_name].energy_required
+    if (energy == nil) then
+        energy = 1
+    end
+    data.raw.recipe[recipe_name].energy_required = energy * factor
+end
+
+table.insert(data.raw["assembling-machine"]["assembling-machine-1"].crafting_categories, "crafting-with-fluid")
 
 {# each randomized tech gets set to be invisible, with new nodes added that trigger those #}
-{%- for original_tech_name, item_name, receiving_player in locations %}
+{%- for original_tech_name, item_name, receiving_player, advancement in locations %}
 original_tech = technologies["{{original_tech_name}}"]
 {#- the tech researched by the local player #}
 new_tree_copy = table.deepcopy(template_tech)
 new_tree_copy.name = "ap-{{ tech_table[original_tech_name] }}-"{# use AP ID #}
 prep_copy(new_tree_copy, original_tech)
 {% if tech_cost != 1 %}
-if new_tree_copy.unit.count then
-    new_tree_copy.unit.count = math.max(1, math.floor(new_tree_copy.unit.count * {{ tech_cost_scale }}))
-end
-{% endif %}
-{% if item_name in tech_table and visibility %}
-{#- copy Factorio Technology Icon #}
-new_tree_copy.icon = table.deepcopy(technologies["{{ item_name }}"].icon)
-new_tree_copy.icons = table.deepcopy(technologies["{{ item_name }}"].icons)
-new_tree_copy.icon_size = table.deepcopy(technologies["{{ item_name }}"].icon_size)
-{% else %}
-{#- use default AP icon if no Factorio graphics exist #}
-new_tree_copy.icon = "__{{ mod_name }}__/graphics/icons/ap.png"
-new_tree_copy.icons = nil
-new_tree_copy.icon_size = 512
+new_tree_copy.unit.count = math.max(1, math.floor(new_tree_copy.unit.count * {{ tech_cost_scale }}))
 {% endif %}
+{%- if item_name in tech_table and visibility -%}
+{#- copy Factorio Technology Icon -#}
+copy_factorio_icon(new_tree_copy, "{{ item_name }}")
+{%- else -%}
+{#- use default AP icon if no Factorio graphics exist -#}
+{% if advancement %}set_ap_icon(new_tree_copy){% else %}set_ap_unimportant_icon(new_tree_copy){% endif %}
+{%- endif -%}
 {#- connect Technology  #}
 {%- if original_tech_name in tech_tree_layout_prerequisites %}
 {%- for prerequesite in tech_tree_layout_prerequisites[original_tech_name] %}
@@ -53,5 +84,9 @@ table.insert(new_tree_copy.prerequisites, "ap-{{ tech_table[prerequesite] }}-")
 {% endif -%}
 {#- add new Technology to game #}
 data:extend{new_tree_copy}
-
-{% endfor %}
+{% endfor %}
+{% if recipe_time_scale %}
+{%- for recipe in recipes %}
+adjust_energy("{{ recipe }}", {{ random.triangular(*recipe_time_scale) }})
+{%- endfor -%}
+{% endif %}

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

@@ -1,17 +1,18 @@
 
 [technology-name]
-{% for original_tech_name, item_name, receiving_player in locations %}
-{%- if visibility %}
+{% for original_tech_name, item_name, receiving_player, advancement in locations %}
+{%- if visibility -%}
 ap-{{ tech_table[original_tech_name] }}-={{ player_names[receiving_player] }}'s {{ item_name }}
-{%- else %}
+{% else %}
 ap-{{ tech_table[original_tech_name] }}-= An Archipelago Sendable
-{%- endif %}
+{%- endif -%}
 {% endfor %}
+
 [technology-description]
-{% for original_tech_name, item_name, receiving_player in locations %}
-{%- if visibility %}
-ap-{{ tech_table[original_tech_name] }}-=Researching this technology sends {{ item_name }} to {{ player_names[receiving_player] }}.
-{%- else %}
+{% for original_tech_name, item_name, receiving_player, advancement in locations %}
+{%- if visibility -%}
+ap-{{ tech_table[original_tech_name] }}-=Researching this technology sends {{ item_name }} to {{ player_names[receiving_player] }}{% if advancement %}, which is considered a logical advancement{% endif %}.
+{% else %}
 ap-{{ tech_table[original_tech_name] }}-=Researching this technology sends something to someone.
-{%- endif %}
+{%- endif -%}
 {% endfor %}

data/factorio/mod_template/macros.lua

@@ -0,0 +1,14 @@
+{% macro dict_to_lua(dict) -%}
+{
+{%- for key, value in dict.items() -%}
+    ["{{ key }}"] = {{ value | safe }}{% if not loop.last %},{% endif %}
+{% endfor -%}
+}
+{%- endmacro %}
+{% macro dict_to_recipe(dict) -%}
+{
+{%- for key, value in dict.items() -%}
+    {"{{ key }}", {{ value | safe }}}{% if not loop.last %},{% endif %}
+{% endfor -%}
+}
+{%- endmacro %}

data/sprites/custom/link.apsprite

@@ -0,0 +1,7 @@
+author: Nintendo
+data: null
+game: A Link to the Past
+min_format_version: 1
+name: Link
+format_version: 1
+sprite_version: 1

data/web/.babelrc

@@ -1,4 +0,0 @@
-{
-  "presets": ["@babel/preset-react", "@babel/preset-env"],
-  "plugins": ["@babel/plugin-proposal-class-properties"]
-}

data/web/.eslintrc.js

@@ -1,40 +0,0 @@
-module.exports = {
-  env: {
-    browser: true,
-    es6: true,
-  },
-  extends: [
-    'plugin:react/recommended',
-    'airbnb',
-  ],
-  parser: 'babel-eslint',
-  globals: {
-    Atomics: 'readonly',
-    SharedArrayBuffer: 'readonly',
-  },
-  parserOptions: {
-    ecmaFeatures: {
-      jsx: true,
-    },
-    ecmaVersion: 2018,
-    sourceType: 'module',
-  },
-  plugins: [
-    'react',
-  ],
-  rules: {
-    "react/jsx-filename-extension": 0,
-    "react/jsx-one-expression-per-line": 0,
-    "react/destructuring-assignment": 0,
-    "react/jsx-curly-spacing": [2, { "when": "always" }],
-    "react/prop-types": 0,
-    "react/no-access-state-in-setstate": 0,
-    "react/button-has-type": 0,
-    "max-len": [2, { code: 120 }],
-    "operator-linebreak": [2, "after"],
-    "no-console": [2, { allow: ["error", "warn"] }],
-    "linebreak-style": 0,
-    "jsx-a11y/no-static-element-interactions": 0,
-    "jsx-a11y/click-events-have-key-events": 0,
-  },
-};

data/web/.gitignore

@@ -1,2 +0,0 @@
-node_modules
-*.map

data/web/package.json

@@ -1,50 +0,0 @@
-{
-  "name": "web-ui",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.jsx",
-  "scripts": {
-    "build": "webpack --config webpack.config.js",
-    "dev": "webpack --config webpack.dev.js"
-  },
-  "author": "LegendaryLinux",
-  "license": "MIT",
-  "dependencies": {
-    "@fortawesome/fontawesome-svg-core": "^1.2.35",
-    "@fortawesome/free-solid-svg-icons": "^5.15.3",
-    "@fortawesome/react-fontawesome": "^0.1.14",
-    "crypto-browserify": "^3.12.0",
-    "crypto-js": "^4.0.0",
-    "css-loader": "^5.1.3",
-    "lodash-es": "^4.17.21",
-    "prop-types": "^15.7.2",
-    "react": "^17.0.1",
-    "react-dom": "^17.0.1",
-    "react-redux": "^7.2.2",
-    "react-router-dom": "^5.2.0",
-    "redux": "^4.0.5",
-    "redux-devtools-extension": "^2.13.9",
-    "sass-loader": "^10.1.1",
-    "style-loader": "^2.0.0",
-    "webpack-cli": "^4.5.0"
-  },
-  "devDependencies": {
-    "@babel/core": "^7.13.10",
-    "@babel/plugin-proposal-class-properties": "^7.13.0",
-    "@babel/preset-env": "^7.13.10",
-    "@babel/preset-react": "^7.12.13",
-    "babel-eslint": "^10.1.0",
-    "babel-loader": "^8.2.2",
-    "buffer": "^6.0.3",
-    "eslint": "^7.22.0",
-    "eslint-config-airbnb": "^18.2.1",
-    "eslint-plugin-import": "^2.22.1",
-    "eslint-plugin-jsx-a11y": "^6.4.1",
-    "eslint-plugin-react": "^7.22.0",
-    "eslint-plugin-react-hooks": "^4.2.0",
-    "file-loader": "^6.2.0",
-    "node-sass": "^5.0.0",
-    "stream-browserify": "^3.0.0",
-    "webpack": "^5.27.1"
-  }
-}

data/web/public/index.html

@@ -1,13 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <title>Berserker Multiworld Web GUI</title>
-    <script type="application/ecmascript" src="assets/index.bundle.js"></script>
-</head>
-<body>
-<div id="app">
-    <!-- Populated by React/JSX -->
-</div>
-</body>
-</html>