Now possible to run generated modded seeds even without the json files.

* Process burnt results.
* Add fluidbox info to machine definition
* Recipe base cost now uses cheapest product source.
* free sample exclusions no longer hard-coded
* science pack pool exclusions no longer hard-coded
* burnt result is forced to have cost of machine used to obtain the results factored into the cost of crafting.
* name of machine is no longer assumed to be name of item.  machine definition now list item sources specifically.
* science pack difficulty is now the minimum of average estimated difficulty of unlocked recipes and 8.
* Actually exclude archipelago-extractor from mod list.

.github/ISSUE_TEMPLATE/bug_report.yaml

@@ -0,0 +1,35 @@
+name: Bug Report
+description: File a bug report.
+title: "Bug: "
+labels:
+  - bug / fix
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this bug report! If this bug occurred during local generation check your 
+        Archipelago install for a log (probably `C:\ProgramData\Archipelago\logs`)
+        and upload it with this report, as well as all yaml files used.
+  - type: textarea
+    id: what-happened
+    attributes:
+      label: What happened?
+    validations:
+      required: true
+  - type: textarea
+    id: expected-results
+    attributes:
+      label: What were the expected results?
+    validations:
+      required: true
+  - type: dropdown
+    id: version
+    attributes:
+      label: Software
+      description: Where did this bug occur?
+      options:
+        - Website
+        - Local generation
+        - While playing
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/feature_request.yaml

@@ -0,0 +1,17 @@
+name: Feature Request
+description: Request a feature!
+title: "Category: "
+labels:
+  - enhancement
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Please replace `Category` in the title with what this feature will be targeting, such as Core generation,
+        website, documentation, or a game.
+        Note: this is not for requesting new games to be added. If you would like to request a game, the best place to
+        ask is about it is in the [discord](https://archipelago.gg/discord).
+  - type: textarea
+    id: feature
+    attributes:
+      label: What feature would you like to see?

.github/ISSUE_TEMPLATE/task.yaml

@@ -0,0 +1,10 @@
+name: Task
+description: Submit a task to be done. If this is not targeting core, it should likely be elsewhere.
+title: "Core: "
+labels:
+  - core
+  - enhancement
+body:
+  - type: textarea
+    attributes:
+      label: What task needs to be completed?

.github/pull_request_template.md

@@ -0,0 +1,12 @@
+Please format your title with what portion of the project this pull request is
+targeting and what it's changing.
+
+ex. "MyGame4: implement new game" or "Docs: add new guide for customizing MyGame3"
+
+## What is this fixing or adding?
+
+
+## How was this tested?
+
+
+## If this makes graphical changes, please attach screenshots.

.github/workflows/build.yml

@@ -4,6 +4,11 @@ name: Build
 
 on: workflow_dispatch
 
+env:
+  SNI_VERSION: v0.0.84
+  ENEMIZER_VERSION: 7.1
+  APPIMAGETOOL_VERSION: 13
+
 jobs:
   # build-release-macos: # LF volunteer
 
@@ -17,9 +22,9 @@ jobs:
           python-version: '3.8'
       - name: Download run-time dependencies
         run: |
-          Invoke-WebRequest -Uri https://github.com/alttpo/sni/releases/download/v0.0.82/sni-v0.0.82-windows-amd64.zip -OutFile sni.zip
+          Invoke-WebRequest -Uri https://github.com/alttpo/sni/releases/download/${Env:SNI_VERSION}/sni-${Env:SNI_VERSION}-windows-amd64.zip -OutFile sni.zip
           Expand-Archive -Path sni.zip -DestinationPath SNI -Force
-          Invoke-WebRequest -Uri https://github.com/Ijwu/Enemizer/releases/download/7.0.1/win-x64.zip -OutFile enemizer.zip
+          Invoke-WebRequest -Uri https://github.com/Ijwu/Enemizer/releases/download/${Env:ENEMIZER_VERSION}/win-x64.zip -OutFile enemizer.zip
           Expand-Archive -Path enemizer.zip -DestinationPath EnemizerCLI -Force
       - name: Build
         run: |
@@ -43,6 +48,7 @@ jobs:
   build-ubuntu1804:
     runs-on: ubuntu-18.04
     steps:
+      # - copy code below to release.yml -
       - uses: actions/checkout@v2
       - name: Install base dependencies
         run: |
@@ -56,18 +62,18 @@ jobs:
       - name: Install build-time dependencies
         run: |
           echo "PYTHON=python3.9" >> $GITHUB_ENV
-          wget -nv https://github.com/AppImage/AppImageKit/releases/download/13/appimagetool-x86_64.AppImage
+          wget -nv https://github.com/AppImage/AppImageKit/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
           chmod a+rx appimagetool-x86_64.AppImage
           ./appimagetool-x86_64.AppImage --appimage-extract
           echo -e '#/bin/sh\n./squashfs-root/AppRun "$@"' > appimagetool
           chmod a+rx appimagetool
       - name: Download run-time dependencies
         run: |
-          wget -nv https://github.com/alttpo/sni/releases/download/v0.0.82/sni-v0.0.82-manylinux2014-amd64.tar.xz
+          wget -nv https://github.com/alttpo/sni/releases/download/$SNI_VERSION/sni-$SNI_VERSION-manylinux2014-amd64.tar.xz
           tar xf sni-*.tar.xz
           rm sni-*.tar.xz
           mv sni-* SNI
-          wget -nv https://github.com/Ijwu/Enemizer/releases/download/7.0.1/ubuntu.16.04-x64.7z
+          wget -nv https://github.com/Ijwu/Enemizer/releases/download/$ENEMIZER_VERSION/ubuntu.16.04-x64.7z
           7za x -oEnemizerCLI/ ubuntu.16.04-x64.7z
       - name: Build
         run: |
@@ -84,6 +90,7 @@ jobs:
           (cd build && DIR_NAME="`ls | grep exe`" && mv "$DIR_NAME" Archipelago && tar -czvf ../dist/$TAR_NAME Archipelago && mv Archipelago "$DIR_NAME")
           echo "APPIMAGE_NAME=$APPIMAGE_NAME" >> $GITHUB_ENV
           echo "TAR_NAME=$TAR_NAME" >> $GITHUB_ENV
+      # - copy code above to release.yml -
       - name: Store AppImage
         uses: actions/upload-artifact@v2
         with:

.github/workflows/lint.yml

@@ -18,8 +18,8 @@ jobs:
         python-version: 3.9
     - name: Install dependencies
       run: |
-        python -m pip install --upgrade pip
-        pip install flake8 pytest
+        python -m pip install --upgrade pip wheel
+        pip install flake8 pytest pytest-subtests
         if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
     - name: Lint with flake8
       run: |

.github/workflows/release.yml

@@ -7,6 +7,11 @@ on:
     tags:
       - '*.*.*'
 
+env:
+  SNI_VERSION: v0.0.84
+  ENEMIZER_VERSION: 7.1
+  APPIMAGETOOL_VERSION: 13
+
 jobs:
   create-release:
     runs-on: ubuntu-latest
@@ -44,22 +49,23 @@ jobs:
       - name: Install build-time dependencies
         run: |
           echo "PYTHON=python3.9" >> $GITHUB_ENV
-          wget -nv https://github.com/AppImage/AppImageKit/releases/download/13/appimagetool-x86_64.AppImage
+          wget -nv https://github.com/AppImage/AppImageKit/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
           chmod a+rx appimagetool-x86_64.AppImage
           ./appimagetool-x86_64.AppImage --appimage-extract
           echo -e '#/bin/sh\n./squashfs-root/AppRun "$@"' > appimagetool
           chmod a+rx appimagetool
       - name: Download run-time dependencies
         run: |
-          wget -nv https://github.com/alttpo/sni/releases/download/v0.0.82/sni-v0.0.82-manylinux2014-amd64.tar.xz
+          wget -nv https://github.com/alttpo/sni/releases/download/$SNI_VERSION/sni-$SNI_VERSION-manylinux2014-amd64.tar.xz
           tar xf sni-*.tar.xz
           rm sni-*.tar.xz
           mv sni-* SNI
-          wget -nv https://github.com/Ijwu/Enemizer/releases/download/7.0.1/ubuntu.16.04-x64.7z
+          wget -nv https://github.com/Ijwu/Enemizer/releases/download/$ENEMIZER_VERSION/ubuntu.16.04-x64.7z
           7za x -oEnemizerCLI/ ubuntu.16.04-x64.7z
       - name: Build
         run: |
-          "${{ env.PYTHON }}" -m pip install --upgrade pip setuptools virtualenv PyGObject  # pygobject should probably move to requirements
+          # pygobject is an optional dependency for kivy that's not in requirements
+          "${{ env.PYTHON }}" -m pip install --upgrade pip virtualenv PyGObject setuptools
           "${{ env.PYTHON }}" -m venv venv
           source venv/bin/activate
           pip install -r requirements.txt

.github/workflows/unittests.yml

@@ -32,8 +32,8 @@ jobs:
         python-version: ${{ matrix.python.version }}
     - name: Install dependencies
       run: |
-        python -m pip install --upgrade pip
-        pip install flake8 pytest
+        python -m pip install --upgrade pip wheel
+        pip install flake8 pytest pytest-subtests
         python ModuleUpdate.py --yes --force --append "WebHostLib/requirements.txt"
     - name: Unittests
       run: |

.gitignore

@@ -28,6 +28,7 @@ README.html
 .vs/
 EnemizerCLI/
 /Players/
+/SNI/
 /options.yaml
 /config.yaml
 /logs/

BaseClasses.py

@@ -955,6 +955,13 @@ class Region:
                 return True
         return False
 
+    def get_connecting_entrance(self, is_main_entrance: typing.Callable[[Entrance], bool]) -> Entrance:
+        for entrance in self.entrances:
+            if is_main_entrance(entrance):
+                return entrance
+        for entrance in self.entrances:  # BFS might be better here, trying DFS for now.
+            return entrance.parent_region.get_connecting_entrance(is_main_entrance)
+
     def __repr__(self):
         return self.__str__()
 
@@ -1422,7 +1429,6 @@ class Spoiler():
                                                "f" in self.world.shop_shuffle[player]))
                     outfile.write('Custom Potion Shop:              %s\n' %
                                   bool_to_text("w" in self.world.shop_shuffle[player]))
-                    outfile.write('Boss shuffle:                    %s\n' % self.world.boss_shuffle[player])
                     outfile.write('Enemy health:                    %s\n' % self.world.enemy_health[player])
                     outfile.write('Enemy damage:                    %s\n' % self.world.enemy_damage[player])
                     outfile.write('Prize shuffle                    %s\n' %

CommonClient.py

@@ -5,6 +5,7 @@ import urllib.parse
 import sys
 import typing
 import time
+import functools
 
 import ModuleUpdate
 ModuleUpdate.update()
@@ -17,7 +18,8 @@ if __name__ == "__main__":
     Utils.init_logging("TextClient", exception_logger="Client")
 
 from MultiServer import CommandProcessor
-from NetUtils import Endpoint, decode, NetworkItem, encode, JSONtoTextParser, ClientStatus, Permission, NetworkSlot
+from NetUtils import Endpoint, decode, NetworkItem, encode, JSONtoTextParser, \
+    ClientStatus, Permission, NetworkSlot, RawJSONtoTextParser
 from Utils import Version, stream_input
 from worlds import network_data_package, AutoWorldRegister
 import os
@@ -152,8 +154,9 @@ class CommonContext:
     # locations
     locations_checked: typing.Set[int]  # local state
     locations_scouted: typing.Set[int]
-    missing_locations: typing.Set[int]
+    missing_locations: typing.Set[int]  # server state
     checked_locations: typing.Set[int]  # server state
+    server_locations: typing.Set[int]  # all locations the server knows of, missing_location | checked_locations
     locations_info: typing.Dict[int, NetworkItem]
 
     # internals
@@ -184,8 +187,9 @@ class CommonContext:
         self.locations_checked = set()  # local state
         self.locations_scouted = set()
         self.items_received = []
-        self.missing_locations = set()
+        self.missing_locations = set()  # server state
         self.checked_locations = set()  # server state
+        self.server_locations = set()  # all locations the server knows of, missing_location | checked_locations
         self.locations_info = {}
 
         self.input_queue = asyncio.Queue()
@@ -202,6 +206,10 @@ class CommonContext:
         # execution
         self.keep_alive_task = asyncio.create_task(keep_alive(self), name="Bouncy")
 
+    @functools.cached_property
+    def raw_text_parser(self) -> RawJSONtoTextParser:
+        return RawJSONtoTextParser(self)
+
     @property
     def total_locations(self) -> typing.Optional[int]:
         """Will return None until connected."""
@@ -345,6 +353,8 @@ class CommonContext:
         cache_package = Utils.persistent_load().get("datapackage", {}).get("games", {})
         needed_updates: typing.Set[str] = set()
         for game in relevant_games:
+            if game not in remote_datepackage_versions:
+                continue
             remote_version: int = remote_datepackage_versions[game]
 
             if remote_version == 0:  # custom datapackage for this game
@@ -632,6 +642,7 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
         # when /missing is used for the client side view of what is missing.
         ctx.missing_locations = set(args["missing_locations"])
         ctx.checked_locations = set(args["checked_locations"])
+        ctx.server_locations = ctx.missing_locations | ctx. checked_locations
 
     elif cmd == 'ReceivedItems':
         start_index = args["index"]

FF1Client.py

@@ -1,4 +1,5 @@
 import asyncio
+import copy
 import json
 import time
 from asyncio import StreamReader, StreamWriter
@@ -6,7 +7,7 @@ from typing import List
 
 
 import Utils
-from CommonClient import CommonContext, server_loop, gui_enabled, console_loop, ClientCommandProcessor, logger, \
+from CommonClient import CommonContext, server_loop, gui_enabled, ClientCommandProcessor, logger, \
     get_base_parser
 
 SYSTEM_MESSAGE_ID = 0
@@ -64,7 +65,7 @@ class FF1Context(CommonContext):
 
     def _set_message(self, msg: str, msg_id: int):
         if DISPLAY_MSGS:
-            self.messages[(time.time(), msg_id)] = msg
+            self.messages[time.time(), msg_id] = msg
 
     def on_package(self, cmd: str, args: dict):
         if cmd == 'Connected':
@@ -73,32 +74,28 @@ class FF1Context(CommonContext):
             msg = args['text']
             if ': !' not in msg:
                 self._set_message(msg, SYSTEM_MESSAGE_ID)
-        elif cmd == "ReceivedItems":
-            msg = f"Received {', '.join([self.item_names[item.item] for item in args['items']])}"
-            self._set_message(msg, SYSTEM_MESSAGE_ID)
-        elif cmd == 'PrintJSON':
-            print_type = args['type']
-            item = args['item']
-            receiving_player_id = args['receiving']
-            receiving_player_name = self.player_names[receiving_player_id]
-            sending_player_id = item.player
-            sending_player_name = self.player_names[item.player]
-            if print_type == 'Hint':
-                msg = f"Hint: Your {self.item_names[item.item]} is at" \
-                      f" {self.player_names[item.player]}'s {self.location_names[item.location]}"
-                self._set_message(msg, item.item)
-            elif print_type == 'ItemSend' and receiving_player_id != self.slot:
-                if sending_player_id == self.slot:
-                    if receiving_player_id == self.slot:
-                        msg = f"You found your own {self.item_names[item.item]}"
-                    else:
-                        msg = f"You sent {self.item_names[item.item]} to {receiving_player_name}"
-                else:
-                    if receiving_player_id == sending_player_id:
-                        msg = f"{sending_player_name} found their {self.item_names[item.item]}"
-                    else:
-                        msg = f"{sending_player_name} sent {self.item_names[item.item]} to " \
-                              f"{receiving_player_name}"
+
+    def on_print_json(self, args: dict):
+        if self.ui:
+            self.ui.print_json(copy.deepcopy(args["data"]))
+        else:
+            text = self.jsontotextparser(copy.deepcopy(args["data"]))
+            logger.info(text)
+        relevant = args.get("type", None) in {"Hint", "ItemSend"}
+        if relevant:
+            item = args["item"]
+            # goes to this world
+            if self.slot_concerns_self(args["receiving"]):
+                relevant = True
+            # found in this world
+            elif self.slot_concerns_self(item.player):
+                relevant = True
+            # not related
+            else:
+                relevant = False
+            if relevant:
+                item = args["item"]
+                msg = self.raw_text_parser(copy.deepcopy(args["data"]))
                 self._set_message(msg, item.item)
 
     def run_gui(self):

FactorioClient.py

@@ -65,6 +65,7 @@ class FactorioContext(CommonContext):
         self.factorio_json_text_parser = FactorioJSONtoTextParser(self)
         self.energy_link_increment = 0
         self.last_deplete = 0
+        self.custom_data_package = 0
 
     async def server_auth(self, password_requested: bool = False):
         if password_requested and not self.password:
@@ -170,7 +171,7 @@ async def game_watcher(ctx: FactorioContext):
                     if ctx.locations_checked != research_data:
                         bridge_logger.debug(
                             f"New researches done: "
-                            f"{[lookup_id_to_name[rid] for rid in research_data - ctx.locations_checked]}")
+                            f"{[lookup_id_to_name.get(rid, f'Unknown Research (ID: {rid})') for rid in research_data - ctx.locations_checked]}")
                         ctx.locations_checked = research_data
                         await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": tuple(research_data)}])
                     death_link_tick = data.get("death_link_tick", 0)
@@ -268,7 +269,11 @@ async def factorio_server_watcher(ctx: FactorioContext):
                     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 Factorio.item_id_to_name:
+                    if ctx.custom_data_package:
+                        item_name = Factorio.item_id_to_name.get(item_id, f"Unknown Item (ID: {item_id})")
+                        factorio_server_logger.info(f"Sending {item_name} to Nauvis from {player_name}.{(' (Item name might not match the seed.)' if Factorio.data_version else '')}")
+                        commands[ctx.send_index] = f'/ap-get-technology {item_id}\t{ctx.send_index}\t{player_name}'
+                    elif item_id not in Factorio.item_id_to_name:
                         factorio_server_logger.error(f"Cannot send unknown item ID: {item_id}")
                     else:
                         item_name = Factorio.item_id_to_name[item_id]
@@ -297,6 +302,7 @@ async def get_info(ctx: FactorioContext, rcon_client: factorio_rcon.RCONClient):
     # 0.2.0 addition, not present earlier
     death_link = bool(info.get("death_link", False))
     ctx.energy_link_increment = info.get("energy_link", 0)
+    ctx.custom_data_package = info.get("custom_data_package", 0)
     logger.debug(f"Energy Link Increment: {ctx.energy_link_increment}")
     if ctx.energy_link_increment and ctx.ui:
         ctx.ui.enable_energy_link()

Fill.py

@@ -136,33 +136,98 @@ def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations:
     itempool.extend(unplaced_items)
 
 
+def remaining_fill(world: MultiWorld,
+                   locations: typing.List[Location],
+                   itempool: typing.List[Item]) -> None:
+    unplaced_items: typing.List[Item] = []
+    placements: typing.List[Location] = []
+    swapped_items: typing.Counter[typing.Tuple[int, str]] = Counter()
+    while locations and itempool:
+        item_to_place = itempool.pop()
+        spot_to_fill: typing.Optional[Location] = None
+
+        for i, location in enumerate(locations):
+            if location.item_rule(item_to_place):
+                # popping by index is faster than removing by content,
+                spot_to_fill = locations.pop(i)
+                # skipping a scan for the element
+                break
+
+        else:
+            # we filled all reachable spots.
+            # try swapping this item with previously placed items
+
+            for (i, location) in enumerate(placements):
+                placed_item = location.item
+                # Unplaceable items can sometimes be swapped infinitely. Limit the
+                # number of times we will swap an individual item to prevent this
+
+                if swapped_items[placed_item.player,
+                                 placed_item.name] > 1:
+                    continue
+
+                location.item = None
+                placed_item.location = None
+                if location.item_rule(item_to_place):
+                    # Add this item to the existing placement, and
+                    # add the old item to the back of the queue
+                    spot_to_fill = placements.pop(i)
+
+                    swapped_items[placed_item.player,
+                                  placed_item.name] += 1
+
+                    itempool.append(placed_item)
+
+                    break
+
+                # Item can't be placed here, restore original item
+                location.item = placed_item
+                placed_item.location = location
+
+            if spot_to_fill is None:
+                # Can't place this item, move on to the next
+                unplaced_items.append(item_to_place)
+                continue
+
+        world.push_item(spot_to_fill, item_to_place, False)
+        placements.append(spot_to_fill)
+
+    if unplaced_items and locations:
+        # There are leftover unplaceable items and locations that won't accept them
+        raise FillError(f'No more spots to place {unplaced_items}, locations {locations} are invalid. '
+                        f'Already placed {len(placements)}: {", ".join(str(place) for place in placements)}')
+
+    itempool.extend(unplaced_items)
+
+
+def fast_fill(world: MultiWorld,
+              item_pool: typing.List[Item],
+              fill_locations: typing.List[Location]) -> typing.Tuple[typing.List[Item], typing.List[Location]]:
+    placing = min(len(item_pool), len(fill_locations))
+    for item, location in zip(item_pool, fill_locations):
+        world.push_item(location, item, False)
+    return item_pool[placing:], fill_locations[placing:]
+
+
 def distribute_items_restrictive(world: MultiWorld) -> None:
     fill_locations = sorted(world.get_unfilled_locations())
     world.random.shuffle(fill_locations)
-
     # get items to distribute
     itempool = sorted(world.itempool)
     world.random.shuffle(itempool)
     progitempool: typing.List[Item] = []
-    nonexcludeditempool: typing.List[Item] = []
-    localrestitempool: typing.Dict[int, typing.List[Item]] = {player: [] for player in range(1, world.players + 1)}
-    nonlocalrestitempool: typing.List[Item] = []
-    restitempool: typing.List[Item] = []
+    usefulitempool: typing.List[Item] = []
+    filleritempool: typing.List[Item] = []
 
     for item in itempool:
         if item.advancement:
             progitempool.append(item)
-        elif item.useful:  # this only gets nonprogression items which should not appear in excluded locations
-            nonexcludeditempool.append(item)
-        elif item.name in world.local_items[item.player].value:
-            localrestitempool[item.player].append(item)
-        elif item.name in world.non_local_items[item.player].value:
-            nonlocalrestitempool.append(item)
+        elif item.useful:
+            usefulitempool.append(item)
         else:
-            restitempool.append(item)
+            filleritempool.append(item)
 
-    call_all(world, "fill_hook", progitempool, nonexcludeditempool,
-             localrestitempool, nonlocalrestitempool, restitempool, fill_locations)
+    call_all(world, "fill_hook", progitempool, usefulitempool, filleritempool, fill_locations)
 
     locations: typing.Dict[LocationProgressType, typing.List[Location]] = {
         loc_type: [] for loc_type in LocationProgressType}
@@ -184,50 +249,16 @@ def distribute_items_restrictive(world: MultiWorld) -> None:
             raise FillError(
                 f'Not enough locations for progress items. There are {len(progitempool)} more items than locations')
 
-    if nonexcludeditempool:
-        world.random.shuffle(defaultlocations)
-        # needs logical fill to not conflict with local items
-        fill_restrictive(
-            world, world.state, defaultlocations, nonexcludeditempool)
-        if nonexcludeditempool:
-            raise FillError(
-                f'Not enough locations for non-excluded items. There are {len(nonexcludeditempool)} more items than locations')
+    remaining_fill(world, excludedlocations, filleritempool)
+    if excludedlocations:
+        raise FillError(
+            f"Not enough filler items for excluded locations. There are {len(excludedlocations)} more locations than items")
 
-    defaultlocations = defaultlocations + excludedlocations
-    world.random.shuffle(defaultlocations)
+    restitempool = usefulitempool + filleritempool
 
-    if any(localrestitempool.values()):  # we need to make sure some fills are limited to certain worlds
-        local_locations: typing.Dict[int, typing.List[Location]] = {player: [] for player in world.player_ids}
-        for location in defaultlocations:
-            local_locations[location.player].append(location)
-        for player_locations in local_locations.values():
-            world.random.shuffle(player_locations)
+    remaining_fill(world, defaultlocations, restitempool)
 
-        for player, items in localrestitempool.items():  # items already shuffled
-            player_local_locations = local_locations[player]
-            for item_to_place in items:
-                if not player_local_locations:
-                    logging.warning(f"Ran out of local locations for player {player}, "
-                                    f"cannot place {item_to_place}.")
-                    break
-                spot_to_fill = player_local_locations.pop()
-                world.push_item(spot_to_fill, item_to_place, False)
-                defaultlocations.remove(spot_to_fill)
-
-    for item_to_place in nonlocalrestitempool:
-        for i, location in enumerate(defaultlocations):
-            if location.player != item_to_place.player:
-                world.push_item(defaultlocations.pop(i), item_to_place, False)
-                break
-        else:
-            raise Exception(f"Could not place non_local_item {item_to_place} among {defaultlocations}. "
-                            f"Too many non-local items for too few remaining locations.")
-
-    world.random.shuffle(defaultlocations)
-
-    restitempool, defaultlocations = fast_fill(
-        world, restitempool, defaultlocations)
-    unplaced = progitempool + restitempool
+    unplaced = restitempool
     unfilled = defaultlocations
 
     if unplaced or unfilled:
@@ -241,15 +272,6 @@ def distribute_items_restrictive(world: MultiWorld) -> None:
         logging.info(f'Per-Player counts: {print_data})')
 
 
-def fast_fill(world: MultiWorld,
-              item_pool: typing.List[Item],
-              fill_locations: typing.List[Location]) -> typing.Tuple[typing.List[Item], typing.List[Location]]:
-    placing = min(len(item_pool), len(fill_locations))
-    for item, location in zip(item_pool, fill_locations):
-        world.push_item(location, item, False)
-    return item_pool[placing:], fill_locations[placing:]
-
-
 def flood_items(world: MultiWorld) -> None:
     # get items to distribute
     world.random.shuffle(world.itempool)

Generate.py

@@ -23,7 +23,6 @@ from worlds.alttp.EntranceRandomizer import parse_arguments
 from Main import main as ERmain
 from BaseClasses import seeddigits, get_seed
 import Options
-from worlds.alttp import Bosses
 from worlds.alttp.Text import TextTable
 from worlds.AutoWorld import AutoWorldRegister
 import copy
@@ -63,7 +62,7 @@ class PlandoSettings(enum.IntFlag):
 
     def __str__(self) -> str:
         if self.value:
-            return ", ".join((flag.name for flag in PlandoSettings if self.value & flag.value))
+            return ", ".join(flag.name for flag in PlandoSettings if self.value & flag.value)
         return "Off"
 
 
@@ -84,11 +83,6 @@ def mystery_argparse():
     parser.add_argument('--seed', help='Define seed number to generate.', type=int)
     parser.add_argument('--multi', default=defaults["players"], type=lambda value: max(int(value), 1))
     parser.add_argument('--spoiler', type=int, default=defaults["spoiler"])
-    parser.add_argument('--lttp_rom', default=options["lttp_options"]["rom_file"],
-                        help="Path to the 1.0 JP LttP Baserom.")  # absolute, relative to cwd or relative to app path
-    parser.add_argument('--sm_rom', default=options["sm_options"]["rom_file"],
-                        help="Path to the 1.0 JP SM Baserom.")
-    parser.add_argument('--enemizercli', default=resolve_path(defaults["enemizer_path"], local_path))
     parser.add_argument('--outputpath', default=resolve_path(options["general_options"]["output_path"], user_path),
                         help="Path to output folder. Absolute or relative to cwd.")  # absolute or relative to cwd
     parser.add_argument('--race', action='store_true', default=defaults["race"])
@@ -183,10 +177,6 @@ def main(args=None, callback=ERmain):
 
     Utils.init_logging(f"Generate_{seed}", loglevel=args.log_level)
 
-    erargs.lttp_rom = args.lttp_rom
-    erargs.sm_rom = args.sm_rom
-    erargs.enemizercli = args.enemizercli
-
     settings_cache: Dict[str, Tuple[argparse.Namespace, ...]] = \
         {fname: (tuple(roll_settings(yaml, args.plando) for yaml in yamls) if args.samesettings else None)
          for fname, yamls in weights_cache.items()}
@@ -346,19 +336,6 @@ def prefer_int(input_data: str) -> Union[str, int]:
         return input_data
 
 
-available_boss_names: Set[str] = {boss.lower() for boss in Bosses.boss_table if boss not in
-                                         {'Agahnim', 'Agahnim2', 'Ganon'}}
-available_boss_locations: Set[str] = {f"{loc.lower()}{f' {level}' if level else ''}" for loc, level in
-                                             Bosses.boss_location_table}
-
-boss_shuffle_options = {None: 'none',
-                        'none': 'none',
-                        'basic': 'basic',
-                        'full': 'full',
-                        'chaos': 'chaos',
-                        'singularity': 'singularity'
-                        }
-
 goals = {
     'ganon': 'ganon',
     'crystals': 'crystals',
@@ -465,42 +442,7 @@ def roll_triggers(weights: dict, triggers: list) -> dict:
     return weights
 
 
-def get_plando_bosses(boss_shuffle: str, plando_options: Set[str]) -> str:
-    if boss_shuffle in boss_shuffle_options:
-        return boss_shuffle_options[boss_shuffle]
-    elif PlandoSettings.bosses in plando_options:
-        options = boss_shuffle.lower().split(";")
-        remainder_shuffle = "none"  # vanilla
-        bosses = []
-        for boss in options:
-            if boss in boss_shuffle_options:
-                remainder_shuffle = boss_shuffle_options[boss]
-            elif "-" in boss:
-                loc, boss_name = boss.split("-")
-                if boss_name not in available_boss_names:
-                    raise ValueError(f"Unknown Boss name {boss_name}")
-                if loc not in available_boss_locations:
-                    raise ValueError(f"Unknown Boss Location {loc}")
-                level = ''
-                if loc.split(" ")[-1] in {"top", "middle", "bottom"}:
-                    # split off level
-                    loc = loc.split(" ")
-                    level = f" {loc[-1]}"
-                    loc = " ".join(loc[:-1])
-                loc = loc.title().replace("Of", "of")
-                if not Bosses.can_place_boss(boss_name.title(), loc, level):
-                    raise ValueError(f"Cannot place {boss_name} at {loc}{level}")
-                bosses.append(boss)
-            elif boss not in available_boss_names:
-                raise ValueError(f"Unknown Boss name or Boss shuffle option {boss}.")
-            else:
-                bosses.append(boss)
-        return ";".join(bosses + [remainder_shuffle])
-    else:
-        raise Exception(f"Boss Shuffle {boss_shuffle} is unknown and boss plando is turned off.")
-
-
-def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str, option: type(Options.Option)):
+def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str, option: type(Options.Option), plando_options: PlandoSettings):
     if option_key in game_weights:
         try:
             if not option.supports_weighting:
@@ -511,10 +453,9 @@ def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str,
         except Exception as e:
             raise Exception(f"Error generating option {option_key} in {ret.game}") from e
         else:
-            if hasattr(player_option, "verify"):
-                player_option.verify(AutoWorldRegister.world_types[ret.game])
+            player_option.verify(AutoWorldRegister.world_types[ret.game], ret.name, plando_options)
     else:
-        setattr(ret, option_key, option(option.default))
+        setattr(ret, option_key, option.from_any(option.default))  # call the from_any here to support default "random"
 
 
 def roll_settings(weights: dict, plando_options: PlandoSettings = PlandoSettings.bosses):
@@ -558,11 +499,11 @@ def roll_settings(weights: dict, plando_options: PlandoSettings = PlandoSettings
 
     if ret.game in AutoWorldRegister.world_types:
         for option_key, option in world_type.option_definitions.items():
-            handle_option(ret, game_weights, option_key, option)
+            handle_option(ret, game_weights, option_key, option, plando_options)
         for option_key, option in Options.per_game_common_options.items():
             # skip setting this option if already set from common_options, defaulting to root option
             if not (option_key in Options.common_options and option_key not in game_weights):
-                handle_option(ret, game_weights, option_key, option)
+                handle_option(ret, game_weights, option_key, option, plando_options)
         if PlandoSettings.items in plando_options:
             ret.plando_items = game_weights.get("plando_items", [])
         if ret.game == "Minecraft" or ret.game == "Ocarina of Time":
@@ -645,8 +586,6 @@ def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
 
     ret.item_functionality = get_choice_legacy('item_functionality', weights)
 
-    boss_shuffle = get_choice_legacy('boss_shuffle', weights)
-    ret.shufflebosses = get_plando_bosses(boss_shuffle, plando_options)
 
     ret.enemy_damage = {None: 'default',
                         'default': 'default',

Launcher.py

@@ -10,16 +10,21 @@ Scroll down to components= to add components to the launcher as well as setup.py
 
 
 import argparse
-from os.path import isfile
-import sys
-from typing import Iterable, Sequence, Callable, Union, Optional
-import subprocess
 import itertools
-from Utils import is_frozen, user_path, local_path, init_logging, open_filename, messagebox,\
-    is_windows, is_macos, is_linux
-from shutil import which
 import shlex
+import subprocess
+import sys
 from enum import Enum, auto
+from os.path import isfile
+from shutil import which
+from typing import Iterable, Sequence, Callable, Union, Optional
+
+if __name__ == "__main__":
+    import ModuleUpdate
+    ModuleUpdate.update()
+
+from Utils import is_frozen, user_path, local_path, init_logging, open_filename, messagebox, \
+    is_windows, is_macos, is_linux
 
 
 def open_host_yaml():
@@ -65,6 +70,7 @@ def browse_files():
         webbrowser.open(file)
 
 
+# noinspection PyArgumentList
 class Type(Enum):
     TOOL = auto()
     FUNC = auto()  # not a real component

LttPAdjuster.py

@@ -83,9 +83,9 @@ def main():
     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('--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'])
@@ -752,6 +752,7 @@ class SpriteSelector():
         self.window['pady'] = 5
         self.spritesPerRow = 32
         self.all_sprites = []
+        self.invalid_sprites = []
         self.sprite_pool = spritePool
 
         def open_custom_sprite_dir(_evt):
@@ -833,6 +834,13 @@ class SpriteSelector():
         self.window.focus()
         tkinter_center_window(self.window)
 
+        if self.invalid_sprites:
+            invalid = sorted(self.invalid_sprites)
+            logging.warning(f"The following sprites are invalid: {', '.join(invalid)}")
+            msg = f"{invalid[0]} "
+            msg += f"and {len(invalid)-1} more are invalid" if len(invalid) > 1 else "is invalid"
+            messagebox.showerror("Invalid sprites detected", msg, parent=self.window)
+
     def remove_from_sprite_pool(self, button, spritename):
         self.callback(("remove", spritename))
         self.spritePoolButtons.buttons.remove(button)
@@ -897,7 +905,13 @@ class SpriteSelector():
         sprites = []
 
         for file in os.listdir(path):
-            sprites.append((file, Sprite(os.path.join(path, file))))
+            if file == '.gitignore':
+                continue
+            sprite = Sprite(os.path.join(path, file))
+            if sprite.valid:
+                sprites.append((file, sprite))
+            else:
+                self.invalid_sprites.append(file)
 
         sprites.sort(key=lambda s: str.lower(s[1].name or "").strip())
 

Main.py

@@ -12,7 +12,7 @@ from typing import Dict, Tuple, Optional, Set
 
 from BaseClasses import MultiWorld, CollectionState, Region, RegionType, LocationProgressType, Location
 from worlds.alttp.Items import item_name_groups
-from worlds.alttp.Regions import lookup_vanilla_location_to_entrance
+from worlds.alttp.Regions import is_main_entrance
 from Fill import distribute_items_restrictive, flood_items, balance_multiworld_progression, distribute_planned
 from worlds.alttp.Shops import SHOP_ID_START, total_shop_slots, FillDisabledShopSlots
 from Utils import output_path, get_options, __version__, version_tuple
@@ -70,7 +70,6 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
     world.required_medallions = args.required_medallions.copy()
     world.game = args.game.copy()
     world.player_name = args.name.copy()
-    world.enemizer = args.enemizercli
     world.sprite = args.sprite.copy()
     world.glitch_triforce = args.glitch_triforce  # This is enabled/disabled globally, no per player option.
 
@@ -250,24 +249,9 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                     output_file_futures.append(
                         pool.submit(AutoWorld.call_single, world, "generate_output", player, temp_dir))
 
-            def get_entrance_to_region(region: Region):
-                for entrance in region.entrances:
-                    if entrance.parent_region.type in (RegionType.DarkWorld, RegionType.LightWorld, RegionType.Generic):
-                        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 world.get_game_players("A Link to the Past") if
-                            world.shuffle[player] != "vanilla" or world.retro_caves[player]}
-
-            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
+            er_hint_data: Dict[int, Dict[int, str]] = {}
+            AutoWorld.call_all(world, 'extend_hint_information', er_hint_data)
 
             checks_in_area = {player: {area: list() for area in ordered_areas}
                               for player in range(1, world.players + 1)}
@@ -277,22 +261,23 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
 
             for location in world.get_filled_locations():
                 if type(location.address) is int:
-                    main_entrance = get_entrance_to_region(location.parent_region)
                     if location.game != "A Link to the Past":
                         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 location.parent_region.type == RegionType.LightWorld:
-                        checks_in_area[location.player]["Light World"].append(location.address)
-                    elif location.parent_region.type == RegionType.DarkWorld:
-                        checks_in_area[location.player]["Dark World"].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)
+                    else:
+                        main_entrance = location.parent_region.get_connecting_entrance(is_main_entrance)
+                        if 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 location.parent_region.type == RegionType.LightWorld:
+                            checks_in_area[location.player]["Light World"].append(location.address)
+                        elif location.parent_region.type == RegionType.DarkWorld:
+                            checks_in_area[location.player]["Dark World"].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 = []
@@ -306,7 +291,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                     player = region.player
                     location_id = SHOP_ID_START + total_shop_slots + index
 
-                    main_entrance = get_entrance_to_region(region)
+                    main_entrance = region.get_connecting_entrance(is_main_entrance)
                     if main_entrance.parent_region.type == RegionType.LightWorld:
                         checks_in_area[player]["Light World"].append(location_id)
                     else:
@@ -341,7 +326,6 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                                       for player, world_precollected in world.precollected_items.items()}
                 precollected_hints = {player: set() for player in range(1, world.players + 1 + len(world.groups))}
 
-
                 for slot in world.player_ids:
                     slot_data[slot] = world.worlds[slot].fill_slot_data()
 

MultiServer.py

@@ -36,6 +36,7 @@ from NetUtils import Endpoint, ClientStatus, NetworkItem, decode, encode, Networ
     SlotType
 
 min_client_version = Version(0, 1, 6)
+print_command_compatability_threshold = Version(0, 3, 5) # Remove backwards compatibility around 0.3.7
 colorama.init()
 
 # functions callable on storable data on the server by clients
@@ -125,6 +126,7 @@ class Context:
     location_names: typing.Dict[int, str] = Utils.KeyedDefaultDict(lambda code: f'Unknown location (ID:{code})')
     all_item_and_group_names: typing.Dict[str, typing.Set[str]]
     forced_auto_forfeits: typing.Dict[str, bool]
+    non_hintable_names: typing.Dict[str, typing.Set[str]]
 
     def __init__(self, host: str, port: int, server_password: str, password: str, location_check_points: int,
                  hint_cost: int, item_cheat: bool, forfeit_mode: str = "disabled", collect_mode="disabled",
@@ -195,7 +197,7 @@ class Context:
         self.item_name_groups = {}
         self.all_item_and_group_names = {}
         self.forced_auto_forfeits = collections.defaultdict(lambda: False)
-        self.non_hintable_names = {}
+        self.non_hintable_names = collections.defaultdict(frozenset)
 
         self._load_game_data()
         self._init_game_data()
@@ -220,11 +222,11 @@ class Context:
             self.all_item_and_group_names[game_name] = \
                 set(game_package["item_name_to_id"]) | set(self.item_name_groups[game_name])
 
-    def item_names_for_game(self, game: str) -> typing.Dict[str, int]:
-        return self.gamespackage[game]["item_name_to_id"]
+    def item_names_for_game(self, game: str) -> typing.Optional[typing.Dict[str, int]]:
+        return self.gamespackage[game]["item_name_to_id"] if game in self.gamespackage else None
 
-    def location_names_for_game(self, game: str) -> typing.Dict[str, int]:
-        return self.gamespackage[game]["location_name_to_id"]
+    def location_names_for_game(self, game: str) -> typing.Optional[typing.Dict[str, int]]:
+        return self.gamespackage[game]["location_name_to_id"] if game in self.gamespackage else None
 
     # General networking
     async def send_msgs(self, endpoint: Endpoint, msgs: typing.Iterable[dict]) -> bool:
@@ -291,20 +293,27 @@ class Context:
 
     # text
 
-    def notify_all(self, text):
+    def notify_all(self, text: str):
         logging.info("Notice (all): %s" % text)
-        self.broadcast_all([{"cmd": "Print", "text": text}])
+        broadcast_text_all(self, text)
 
     def notify_client(self, client: Client, text: str):
         if not client.auth:
             return
         logging.info("Notice (Player %s in team %d): %s" % (client.name, client.team + 1, text))
-        asyncio.create_task(self.send_msgs(client, [{"cmd": "Print", "text": text}]))
+        if client.version >= print_command_compatability_threshold:
+            asyncio.create_task(self.send_msgs(client, [{"cmd": "PrintJSON", "data": [{ "text": text }]}]))
+        else:
+            asyncio.create_task(self.send_msgs(client, [{"cmd": "Print", "text": text}]))
 
     def notify_client_multiple(self, client: Client, texts: typing.List[str]):
         if not client.auth:
             return
-        asyncio.create_task(self.send_msgs(client, [{"cmd": "Print", "text": text} for text in texts]))
+        if client.version >= print_command_compatability_threshold:
+            asyncio.create_task(self.send_msgs(client, 
+                [{"cmd": "PrintJSON", "data": [{ "text": text }]} for text in texts]))
+        else:
+            asyncio.create_task(self.send_msgs(client, [{"cmd": "Print", "text": text} for text in texts]))
 
     # loading
 
@@ -585,6 +594,7 @@ class Context:
             forfeit_player(self, client.team, client.slot)
         elif self.forced_auto_forfeits[self.games[client.slot]]:
             forfeit_player(self, client.team, client.slot)
+        self.save()  # save goal completion flag
 
 
 def notify_hints(ctx: Context, team: int, hints: typing.List[NetUtils.Hint], only_new: bool = False):
@@ -721,20 +731,37 @@ async def on_client_left(ctx: Context, client: Client):
     ctx.client_connection_timers[client.team, client.slot] = datetime.datetime.now(datetime.timezone.utc)
 
 
-async def countdown(ctx: Context, timer):
-    ctx.notify_all(f'[Server]: Starting countdown of {timer}s')
+async def countdown(ctx: Context, timer: int):
+    broadcast_countdown(ctx, timer, f"[Server]: Starting countdown of {timer}s")
     if ctx.countdown_timer:
         ctx.countdown_timer = timer  # timer is already running, set it to a different time
     else:
         ctx.countdown_timer = timer
         while ctx.countdown_timer > 0:
-            ctx.notify_all(f'[Server]: {ctx.countdown_timer}')
+            broadcast_countdown(ctx, ctx.countdown_timer, f"[Server]: {ctx.countdown_timer}")
             ctx.countdown_timer -= 1
             await asyncio.sleep(1)
-        ctx.notify_all(f'[Server]: GO')
+        broadcast_countdown(ctx, 0, f"[Server]: GO")
         ctx.countdown_timer = 0
 
 
+def broadcast_text_all(ctx: Context, text: str, additional_arguments: dict = {}):
+    old_clients, new_clients = [], []
+
+    for teams in ctx.clients.values():
+        for clients in teams.values():
+            for client in clients:
+                new_clients.append(client) if client.version >= print_command_compatability_threshold \
+                    else old_clients.append(client)
+
+    ctx.broadcast(old_clients, [{"cmd": "Print", "text": text }])
+    ctx.broadcast(new_clients, [{**{"cmd": "PrintJSON", "data": [{ "text": text }]}, **additional_arguments}])
+
+
+def broadcast_countdown(ctx: Context, timer: int, message: str):
+    broadcast_text_all(ctx, message, {"type": "Countdown", "countdown": timer})
+
+
 def get_players_string(ctx: Context):
     auth_clients = {(c.team, c.slot) for c in ctx.endpoints if c.auth}
 
@@ -874,14 +901,14 @@ def register_location_checks(ctx: Context, team: int, slot: int, locations: typi
         ctx.save()
 
 
-def collect_hints(ctx: Context, team: int, slot: int, item_name: str) -> typing.List[NetUtils.Hint]:
+def collect_hints(ctx: Context, team: int, slot: int, item: typing.Union[int, str]) -> typing.List[NetUtils.Hint]:
     hints = []
     slots: typing.Set[int] = {slot}
     for group_id, group in ctx.groups.items():
         if slot in group:
             slots.add(group_id)
 
-    seeked_item_id = ctx.item_names_for_game(ctx.games[slot])[item_name]
+    seeked_item_id = item if isinstance(item, int) else ctx.item_names_for_game(ctx.games[slot])[item]
     for finding_player, check_data in ctx.locations.items():
         for location_id, (item_id, receiving_player, item_flags) in check_data.items():
             if receiving_player in slots and item_id == seeked_item_id:
@@ -1309,13 +1336,33 @@ class ClientMessageProcessor(CommonCommandProcessor):
             self.output(f"A hint costs {self.ctx.get_hint_cost(self.client.slot)} points. "
                         f"You have {points_available} points.")
             return True
+
+        elif input_text.isnumeric():
+            game = self.ctx.games[self.client.slot]
+            hint_id = int(input_text)
+            hint_name = self.ctx.item_names[hint_id] \
+                if not for_location and hint_id in self.ctx.item_names \
+                else self.ctx.location_names[hint_id] \
+                if for_location and hint_id in self.ctx.location_names \
+                else None
+            if hint_name in self.ctx.non_hintable_names[game]:
+                self.output(f"Sorry, \"{hint_name}\" is marked as non-hintable.")
+                hints = []
+            elif not for_location:
+                hints = collect_hints(self.ctx, self.client.team, self.client.slot, hint_id)
+            else:
+                hints = collect_hint_location_id(self.ctx, self.client.team, self.client.slot, hint_id)
+
         else:
             game = self.ctx.games[self.client.slot]
+            if game not in self.ctx.all_item_and_group_names:
+                self.output("Can't look up item/location for unknown game. Hint for ID instead.")
+                return False
             names = self.ctx.location_names_for_game(game) \
                 if for_location else \
                 self.ctx.all_item_and_group_names[game]
-            hint_name, usable, response = get_intended_text(input_text,
-                                                            names)
+            hint_name, usable, response = get_intended_text(input_text, names)
+
             if usable:
                 if hint_name in self.ctx.non_hintable_names[game]:
                     self.output(f"Sorry, \"{hint_name}\" is marked as non-hintable.")
@@ -1329,63 +1376,65 @@ class ClientMessageProcessor(CommonCommandProcessor):
                     hints = collect_hints(self.ctx, self.client.team, self.client.slot, hint_name)
                 else:  # location name
                     hints = collect_hint_location_name(self.ctx, self.client.team, self.client.slot, hint_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
-                    if old_hints:
-                        notify_hints(self.ctx, self.client.team, list(old_hints))
-                        if not new_hints:
-                            self.output("Hint was previously used, no points deducted.")
-                    if new_hints:
-                        found_hints = [hint for hint in new_hints if hint.found]
-                        not_found_hints = [hint for hint in new_hints if not hint.found]
 
-                        if not not_found_hints:  # everything's been found, no need to pay
-                            can_pay = 1000
-                        elif cost:
-                            can_pay = int((points_available // cost) > 0)  # limit to 1 new hint per call
-                        else:
-                            can_pay = 1000
-
-                        self.ctx.random.shuffle(not_found_hints)
-                        # By popular vote, make hints prefer non-local placements
-                        not_found_hints.sort(key=lambda hint: int(hint.receiving_player != hint.finding_player))
-
-                        hints = found_hints
-                        while can_pay > 0:
-                            if not not_found_hints:
-                                break
-                            hint = not_found_hints.pop()
-                            hints.append(hint)
-                            can_pay -= 1
-                            self.ctx.hints_used[self.client.team, self.client.slot] += 1
-                            points_available = get_client_points(self.ctx, self.client)
-
-                        if not_found_hints:
-                            if hints and cost and int((points_available // cost) == 0):
-                                self.output(
-                                    f"There may be more hintables, however, you cannot afford to pay for any more. "
-                                    f" You have {points_available} and need at least "
-                                    f"{self.ctx.get_hint_cost(self.client.slot)}.")
-                            elif hints:
-                                self.output(
-                                    "There may be more hintables, you can rerun the command to find more.")
-                            else:
-                                self.output(f"You can't afford the hint. "
-                                            f"You have {points_available} points and need at least "
-                                            f"{self.ctx.get_hint_cost(self.client.slot)}.")
-                        notify_hints(self.ctx, self.client.team, hints)
-                        self.ctx.save()
-                        return True
-
-                else:
-                    self.output("Nothing found. Item/Location may not exist.")
-                    return False
             else:
                 self.output(response)
                 return False
 
+        if hints:
+            cost = self.ctx.get_hint_cost(self.client.slot)
+            new_hints = set(hints) - self.ctx.hints[self.client.team, self.client.slot]
+            old_hints = set(hints) - new_hints
+            if old_hints:
+                notify_hints(self.ctx, self.client.team, list(old_hints))
+                if not new_hints:
+                    self.output("Hint was previously used, no points deducted.")
+            if new_hints:
+                found_hints = [hint for hint in new_hints if hint.found]
+                not_found_hints = [hint for hint in new_hints if not hint.found]
+
+                if not not_found_hints:  # everything's been found, no need to pay
+                    can_pay = 1000
+                elif cost:
+                    can_pay = int((points_available // cost) > 0)  # limit to 1 new hint per call
+                else:
+                    can_pay = 1000
+
+                self.ctx.random.shuffle(not_found_hints)
+                # By popular vote, make hints prefer non-local placements
+                not_found_hints.sort(key=lambda hint: int(hint.receiving_player != hint.finding_player))
+
+                hints = found_hints
+                while can_pay > 0:
+                    if not not_found_hints:
+                        break
+                    hint = not_found_hints.pop()
+                    hints.append(hint)
+                    can_pay -= 1
+                    self.ctx.hints_used[self.client.team, self.client.slot] += 1
+                    points_available = get_client_points(self.ctx, self.client)
+
+                if not_found_hints:
+                    if hints and cost and int((points_available // cost) == 0):
+                        self.output(
+                            f"There may be more hintables, however, you cannot afford to pay for any more. "
+                            f" You have {points_available} and need at least "
+                            f"{self.ctx.get_hint_cost(self.client.slot)}.")
+                    elif hints:
+                        self.output(
+                            "There may be more hintables, you can rerun the command to find more.")
+                    else:
+                        self.output(f"You can't afford the hint. "
+                                    f"You have {points_available} points and need at least "
+                                    f"{self.ctx.get_hint_cost(self.client.slot)}.")
+                notify_hints(self.ctx, self.client.team, hints)
+                self.ctx.save()
+                return True
+
+        else:
+            self.output("Nothing found. Item/Location may not exist.")
+            return False
+
     @mark_raw
     def _cmd_hint(self, item_name: str = "") -> bool:
         """Use !hint {item_name},
@@ -1833,17 +1882,25 @@ class ServerCommandProcessor(CommonCommandProcessor):
         seeked_player, usable, response = get_intended_text(player_name, self.ctx.player_names.values())
         if usable:
             team, slot = self.ctx.player_name_lookup[seeked_player]
-            item_name = " ".join(item_name)
             game = self.ctx.games[slot]
-            item_name, usable, response = get_intended_text(item_name, self.ctx.all_item_and_group_names[game])
+            full_name = " ".join(item_name)
+
+            if full_name.isnumeric():
+                item, usable, response = int(full_name), True, None
+            elif game in self.ctx.all_item_and_group_names:
+                item, usable, response = get_intended_text(full_name, self.ctx.all_item_and_group_names[game])
+            else:
+                self.output("Can't look up item for unknown game. Hint for ID instead.")
+                return False
+
             if usable:
-                if item_name in self.ctx.item_name_groups[game]:
+                if game in self.ctx.item_name_groups and item in self.ctx.item_name_groups[game]:
                     hints = []
-                    for item_name_from_group in self.ctx.item_name_groups[game][item_name]:
+                    for item_name_from_group in self.ctx.item_name_groups[game][item]:
                         if item_name_from_group in self.ctx.item_names_for_game(game):  # ensure item has an ID
                             hints.extend(collect_hints(self.ctx, team, slot, item_name_from_group))
-                else:  # item name
-                    hints = collect_hints(self.ctx, team, slot, item_name)
+                else:  # item name or id
+                    hints = collect_hints(self.ctx, team, slot, item)
 
                 if hints:
                     notify_hints(self.ctx, team, hints)
@@ -1864,11 +1921,22 @@ class ServerCommandProcessor(CommonCommandProcessor):
         seeked_player, usable, response = get_intended_text(player_name, self.ctx.player_names.values())
         if usable:
             team, slot = self.ctx.player_name_lookup[seeked_player]
-            location_name = " ".join(location_name)
-            location_name, usable, response = get_intended_text(location_name,
-                                                                self.ctx.location_names_for_game(self.ctx.games[slot]))
+            game = self.ctx.games[slot]
+            full_name = " ".join(location_name)
+
+            if full_name.isnumeric():
+                location, usable, response = int(full_name), True, None
+            elif self.ctx.location_names_for_game(game) is not None:
+                location, usable, response = get_intended_text(full_name, self.ctx.location_names_for_game(game))
+            else:
+                self.output("Can't look up location for unknown game. Hint for ID instead.")
+                return False
+
             if usable:
-                hints = collect_hint_location_name(self.ctx, team, slot, location_name)
+                if isinstance(location, int):
+                    hints = collect_hint_location_id(self.ctx, team, slot, location)
+                else:
+                    hints = collect_hint_location_name(self.ctx, team, slot, location)
                 if hints:
                     notify_hints(self.ctx, team, hints)
                 else:
@@ -2018,15 +2086,28 @@ async def main(args: argparse.Namespace):
                   args.auto_shutdown, args.compatibility, args.log_network)
     data_filename = args.multidata
 
-    try:
-        if not data_filename:
+    if not data_filename:
+        try:
             filetypes = (("Multiworld data", (".archipelago", ".zip")),)
             data_filename = Utils.open_filename("Select multiworld data", filetypes)
 
+        except Exception as e:
+            if isinstance(e, ImportError) or (e.__class__.__name__ == "TclError" and "no display" in str(e)):
+                if not isinstance(e, ImportError):
+                    logging.error(f"Failed to load tkinter ({e})")
+                logging.info("Pass a multidata filename on command line to run headless.")
+                exit(1)
+            raise
+
+        if not data_filename:
+            logging.info("No file selected. Exiting.")
+            exit(1)
+
+    try:
         ctx.load(data_filename, args.use_embedded_options)
 
     except Exception as e:
-        logging.exception('Failed to read multiworld data (%s)' % e)
+        logging.exception(f"Failed to read multiworld data ({e})")
         raise
 
     ctx.init_save(not args.disable_save)

Options.py

@@ -26,15 +26,31 @@ class AssembleOptions(abc.ABCMeta):
 
         attrs["name_lookup"].update({option_id: name for name, option_id in new_options.items()})
         options.update(new_options)
-
         # apply aliases, without name_lookup
         aliases = {name[6:].lower(): option_id for name, option_id in attrs.items() if
                    name.startswith("alias_")}
 
         assert "random" not in aliases, "Choice option 'random' cannot be manually assigned."
 
+        # auto-alias Off and On being parsed as True and False
+        if "off" in options:
+            options["false"] = options["off"]
+        if "on" in options:
+            options["true"] = options["on"]
+
         options.update(aliases)
 
+        if "verify" not in attrs:
+            # not overridden by class -> look up bases
+            verifiers = [f for f in (getattr(base, "verify", None) for base in bases) if f]
+            if len(verifiers) > 1:  # verify multiple bases/mixins
+                def verify(self, *args, **kwargs) -> None:
+                    for f in verifiers:
+                        f(self, *args, **kwargs)
+                attrs["verify"] = verify
+            else:
+                assert verifiers, "class Option is supposed to implement def verify"
+
         # auto-validate schema on __init__
         if "schema" in attrs.keys():
 
@@ -112,6 +128,41 @@ class Option(typing.Generic[T], metaclass=AssembleOptions):
     def from_any(cls, data: typing.Any) -> Option[T]:
         raise NotImplementedError
 
+    if typing.TYPE_CHECKING:
+        from Generate import PlandoSettings
+        from worlds.AutoWorld import World
+
+        def verify(self, world: World, player_name: str, plando_options: PlandoSettings) -> None:
+            pass
+    else:
+        def verify(self, *args, **kwargs) -> None:
+            pass
+
+
+class FreeText(Option):
+    """Text option that allows users to enter strings.
+    Needs to be validated by the world or option definition."""
+
+    def __init__(self, value: str):
+        assert isinstance(value, str), "value of FreeText must be a string"
+        self.value = value
+
+    @property
+    def current_key(self) -> str:
+        return self.value
+
+    @classmethod
+    def from_text(cls, text: str) -> FreeText:
+        return cls(text)
+
+    @classmethod
+    def from_any(cls, data: typing.Any) -> FreeText:
+        return cls.from_text(str(data))
+
+    @classmethod
+    def get_option_name(cls, value: T) -> str:
+        return value
+
 
 class NumericOption(Option[int], numbers.Integral):
     # note: some of the `typing.Any`` here is a result of unresolved issue in python standards
@@ -298,7 +349,7 @@ class Toggle(NumericOption):
         if type(data) == str:
             return cls.from_text(data)
         else:
-            return cls(data)
+            return cls(int(data))
 
     @classmethod
     def get_option_name(cls, value):
@@ -368,6 +419,53 @@ class Choice(NumericOption):
     __hash__ = Option.__hash__  # see https://docs.python.org/3/reference/datamodel.html#object.__hash__
 
 
+class TextChoice(Choice):
+    """Allows custom string input and offers choices. Choices will resolve to int and text will resolve to string"""
+
+    def __init__(self, value: typing.Union[str, int]):
+        assert isinstance(value, str) or isinstance(value, int), \
+            f"{value} is not a valid option for {self.__class__.__name__}"
+        self.value = value
+        super(TextChoice, self).__init__()
+
+    @property
+    def current_key(self) -> str:
+        if isinstance(self.value, str):
+            return self.value
+        else:
+            return self.name_lookup[self.value]
+
+    @classmethod
+    def from_text(cls, text: str) -> TextChoice:
+        if text.lower() == "random":  # chooses a random defined option but won't use any free text options
+            return cls(random.choice(list(cls.name_lookup)))
+        for option_name, value in cls.options.items():
+            if option_name.lower() == text.lower():
+                return cls(value)
+        return cls(text)
+
+    @classmethod
+    def get_option_name(cls, value: T) -> str:
+        if isinstance(value, str):
+            return value
+        return cls.name_lookup[value]
+
+    def __eq__(self, other: typing.Any):
+        if isinstance(other, self.__class__):
+            return other.value == self.value
+        elif isinstance(other, str):
+            if other in self.options:
+                return other == self.current_key
+            return other == self.value
+        elif isinstance(other, int):
+            assert other in self.name_lookup, f"compared against an int that could never be equal. {self} == {other}"
+            return other == self.value
+        elif isinstance(other, bool):
+            return other == bool(self.value)
+        else:
+            raise TypeError(f"Can't compare {self.__class__.__name__} with {other.__class__.__name__}")
+
+
 class Range(NumericOption):
     range_start = 0
     range_end = 1
@@ -385,7 +483,7 @@ class Range(NumericOption):
         if text.startswith("random"):
             return cls.weighted_range(text)
         elif text == "default" and hasattr(cls, "default"):
-            return cls(cls.default)
+            return cls.from_any(cls.default)
         elif text == "high":
             return cls(cls.range_end)
         elif text == "low":
@@ -396,7 +494,7 @@ class Range(NumericOption):
                 and text in ("true", "false"):
             # these are the conditions where "true" and "false" make sense
             if text == "true":
-                return cls(cls.default)
+                return cls.from_any(cls.default)
             else:  # "false"
                 return cls(0)
         return cls(int(text))
@@ -507,7 +605,7 @@ class VerifyKeys:
                 raise Exception(f"Found unexpected key {', '.join(extra)} in {cls}. "
                                 f"Allowed keys: {cls.valid_keys}.")
 
-    def verify(self, world):
+    def verify(self, world, player_name: str, plando_options) -> None:
         if self.convert_name_groups and self.verify_item_name:
             new_value = type(self.value)()  # empty container of whatever value is
             for item_name in self.value:
@@ -600,10 +698,7 @@ class OptionSet(Option[typing.Set[str]], VerifyKeys):
 
     @classmethod
     def from_any(cls, data: typing.Any):
-        if type(data) == list:
-            cls.verify_keys(data)
-            return cls(data)
-        elif type(data) == set:
+        if isinstance(data, (list, set, frozenset)):
             cls.verify_keys(data)
             return cls(data)
         return cls.from_text(str(data))
@@ -732,8 +827,8 @@ class ItemLinks(OptionList):
                 pool |= {item_name}
         return pool
 
-    def verify(self, world):
-        super(ItemLinks, self).verify(world)
+    def verify(self, world, player_name: str, plando_options) -> None:
+        super(ItemLinks, self).verify(world, player_name, plando_options)
         existing_links = set()
         for link in self.value:
             if link["name"] in existing_links:

Patch.py

@@ -17,7 +17,7 @@ ModuleUpdate.update()
 
 import Utils
 
-current_patch_version = 4
+current_patch_version = 5
 
 
 class AutoPatchRegister(type):
@@ -128,6 +128,7 @@ class APDeltaPatch(APContainer, metaclass=AutoPatchRegister):
         manifest = super(APDeltaPatch, self).get_manifest()
         manifest["base_checksum"] = self.hash
         manifest["result_file_ending"] = self.result_file_ending
+        manifest["patch_file_ending"] = self.patch_file_ending
         return manifest
 
     @classmethod

README.md

@@ -61,26 +61,10 @@ This project makes use of multiple other projects. We wouldn't be here without t
 * [Ocarina of Time Randomizer](https://github.com/TestRunnerSRL/OoT-Randomizer)
 
 ## Contributing
-Contributions are welcome. We have a few asks of any new contributors.
-
-* Ensure that all changes which affect logic are covered by unit tests. 
-* Do not introduce any unit test failures/regressions.
-
-Otherwise, we tend to judge code on a case to case basis. It is a generally good idea to stick to PEP-8 guidelines to ensure consistency with existing code. (And to make the linter happy.)
-
-For adding a new game to Archipelago and other documentation on how Archipelago functions, please see [the docs folder](docs/) for the relevant information and feel free to ask any questions in the #archipelago-dev channel in our discord.
+For contribution guidelines, please see our [Contributing doc.](/docs/contributing.md)
 
 ## FAQ
-For frequently asked questions see the website's [FAQ Page](https://archipelago.gg/faq/en/)
+For Frequently asked questions, please see the website's [FAQ Page.](https://archipelago.gg/faq/en/)
 
 ## Code of Conduct
-We conduct ourselves openly and inclusively here. Please do not contribute to an environment which makes other people uncomfortable. This means that we expect all contributors or participants here to:
-
-* Be welcoming and inclusive in tone and language.
-* Be respectful of others and their abilities.
-* Show empathy when speaking with others.
-* Be gracious and accept feedback and constructive criticism.
-
-These guidelines apply to all channels of communication within this GitHub repository. Please be respectful in both public channels, such as issues, and private, such as private messaging or emails.
-
-Any incidents of abuse may be reported directly to Ijwu at hmfarran@gmail.com.
+Please refer to our [code of conduct.](/docs/code_of_conduct.md)

SNIClient.py

@@ -15,9 +15,6 @@ import typing
 
 from json import loads, dumps
 
-import ModuleUpdate
-ModuleUpdate.update()
-
 from Utils import init_logging, messagebox
 
 if __name__ == "__main__":
@@ -149,8 +146,8 @@ class Context(CommonContext):
     def event_invalid_slot(self):
         if self.snes_socket is not None and not self.snes_socket.closed:
             asyncio.create_task(self.snes_socket.close())
-        raise Exception('Invalid ROM detected, '
-                        'please verify that you have loaded the correct rom and reconnect your snes (/snes)')
+        raise Exception("Invalid ROM detected, "
+                        "please verify that you have loaded the correct rom and reconnect your snes (/snes)")
 
     async def server_auth(self, password_requested: bool = False):
         if password_requested and not self.password:
@@ -158,7 +155,7 @@ class Context(CommonContext):
         if self.rom is None:
             self.awaiting_rom = True
             snes_logger.info(
-                'No ROM detected, awaiting snes connection to authenticate to the multiworld server (/snes)')
+                "No ROM detected, awaiting snes connection to authenticate to the multiworld server (/snes)")
             return
         self.awaiting_rom = False
         self.auth = self.rom
@@ -262,7 +259,7 @@ async def deathlink_kill_player(ctx: Context):
 
 SNES_RECONNECT_DELAY = 5
 
-# LttP
+# FXPAK Pro protocol memory mapping used by SNI
 ROM_START = 0x000000
 WRAM_START = 0xF50000
 WRAM_SIZE = 0x20000
@@ -293,21 +290,24 @@ SHOP_LEN = (len(Shops.shop_table) * 3) + 5
 DEATH_LINK_ACTIVE_ADDR = ROMNAME_START + 0x15       # 1 byte
 
 # SM
-SM_ROMNAME_START = 0x007FC0
+SM_ROMNAME_START = ROM_START + 0x007FC0
 
 SM_INGAME_MODES = {0x07, 0x09, 0x0b}
 SM_ENDGAME_MODES = {0x26, 0x27}
 SM_DEATH_MODES = {0x15, 0x17, 0x18, 0x19, 0x1A}
 
-SM_RECV_PROGRESS_ADDR = SRAM_START + 0x2000         # 2 bytes
-SM_RECV_ITEM_ADDR = SAVEDATA_START + 0x4D2          # 1 byte
-SM_RECV_ITEM_PLAYER_ADDR = SAVEDATA_START + 0x4D3   # 1 byte
+# RECV and SEND are from the gameplay's perspective: SNIClient writes to RECV queue and reads from SEND queue
+SM_RECV_QUEUE_START  = SRAM_START + 0x2000
+SM_RECV_QUEUE_WCOUNT = SRAM_START + 0x2602
+SM_SEND_QUEUE_START  = SRAM_START + 0x2700
+SM_SEND_QUEUE_RCOUNT = SRAM_START + 0x2680
+SM_SEND_QUEUE_WCOUNT = SRAM_START + 0x2682
 
 SM_DEATH_LINK_ACTIVE_ADDR = ROM_START + 0x277f04    # 1 byte
 SM_REMOTE_ITEM_FLAG_ADDR = ROM_START + 0x277f06    # 1 byte
 
 # SMZ3
-SMZ3_ROMNAME_START = 0x00FFC0
+SMZ3_ROMNAME_START = ROM_START + 0x00FFC0
 
 SMZ3_INGAME_MODES = {0x07, 0x09, 0x0b}
 SMZ3_ENDGAME_MODES = {0x26, 0x27}
@@ -1083,6 +1083,9 @@ async def game_watcher(ctx: Context):
 
             if ctx.awaiting_rom:
                 await ctx.server_auth(False)
+            elif ctx.server is None:
+                snes_logger.warning("ROM detected but no active multiworld server connection. " +
+                                    "Connect using command: /connect server:port")
 
         if ctx.auth and ctx.auth != ctx.rom:
             snes_logger.warning("ROM change detected, please reconnect to the multiworld server")
@@ -1159,6 +1162,9 @@ async def game_watcher(ctx: Context):
                 await ctx.send_msgs([{"cmd": "LocationScouts", "locations": [scout_location]}])
             await track_locations(ctx, roomid, roomdata)
         elif ctx.game == GAME_SM:
+            if ctx.server is None or ctx.slot is None:
+                # not successfully connected to a multiworld server, cannot process the game sending items
+                continue
             gamemode = await snes_read(ctx, WRAM_START + 0x0998, 1)
             if "DeathLink" in ctx.tags and gamemode and ctx.last_death_link + 1 < time.time():
                 currently_dead = gamemode[0] in SM_DEATH_MODES
@@ -1169,25 +1175,25 @@ async def game_watcher(ctx: Context):
                     ctx.finished_game = True
                 continue
 
-            data = await snes_read(ctx, SM_RECV_PROGRESS_ADDR + 0x680, 4)
+            data = await snes_read(ctx, SM_SEND_QUEUE_RCOUNT, 4)
             if data is None:
                 continue
 
             recv_index = data[0] | (data[1] << 8)
-            recv_item = data[2] | (data[3] << 8)
+            recv_item = data[2] | (data[3] << 8) # this is actually SM_SEND_QUEUE_WCOUNT
 
             while (recv_index < recv_item):
                 itemAdress = recv_index * 8
-                message = await snes_read(ctx, SM_RECV_PROGRESS_ADDR + 0x700 + itemAdress, 8)
+                message = await snes_read(ctx, SM_SEND_QUEUE_START + itemAdress, 8)
                 # worldId = message[0] | (message[1] << 8)  # unused
                 # itemId = message[2] | (message[3] << 8)  # unused
                 itemIndex = (message[4] | (message[5] << 8)) >> 3
 
                 recv_index += 1
-                snes_buffered_write(ctx, SM_RECV_PROGRESS_ADDR + 0x680,
+                snes_buffered_write(ctx, SM_SEND_QUEUE_RCOUNT,
                                     bytes([recv_index & 0xFF, (recv_index >> 8) & 0xFF]))
 
-                from worlds.sm.Locations import locations_start_id
+                from worlds.sm import locations_start_id
                 location_id = locations_start_id + itemIndex
 
                 ctx.locations_checked.add(location_id)
@@ -1196,15 +1202,14 @@ async def game_watcher(ctx: Context):
                     f'New Check: {location} ({len(ctx.locations_checked)}/{len(ctx.missing_locations) + len(ctx.checked_locations)})')
                 await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": [location_id]}])
 
-            data = await snes_read(ctx, SM_RECV_PROGRESS_ADDR + 0x600, 4)
+            data = await snes_read(ctx, SM_RECV_QUEUE_WCOUNT, 2)
             if data is None:
                 continue
 
-            # recv_itemOutPtr = data[0] | (data[1] << 8) # unused
-            itemOutPtr = data[2] | (data[3] << 8)
+            itemOutPtr = data[0] | (data[1] << 8)
 
-            from worlds.sm.Items import items_start_id
-            from worlds.sm.Locations import locations_start_id
+            from worlds.sm import items_start_id
+            from worlds.sm import locations_start_id
             if itemOutPtr < len(ctx.items_received):
                 item = ctx.items_received[itemOutPtr]
                 itemId = item.item - items_start_id
@@ -1214,10 +1219,10 @@ async def game_watcher(ctx: Context):
                     locationId = 0x00 #backward compat
 
                 playerID = item.player if item.player <= SM_ROM_PLAYER_LIMIT else 0
-                snes_buffered_write(ctx, SM_RECV_PROGRESS_ADDR + itemOutPtr * 4, bytes(
+                snes_buffered_write(ctx, SM_RECV_QUEUE_START + itemOutPtr * 4, bytes(
                 	[playerID & 0xFF, (playerID >> 8) & 0xFF, itemId & 0xFF, locationId & 0xFF]))
                 itemOutPtr += 1
-                snes_buffered_write(ctx, SM_RECV_PROGRESS_ADDR + 0x602,
+                snes_buffered_write(ctx, SM_RECV_QUEUE_WCOUNT,
                                     bytes([itemOutPtr & 0xFF, (itemOutPtr >> 8) & 0xFF]))
                 logging.info('Received %s from %s (%s) (%d/%d in list)' % (
                     color(ctx.item_names[item.item], 'red', 'bold'),
@@ -1225,6 +1230,9 @@ async def game_watcher(ctx: Context):
                     ctx.location_names[item.location], itemOutPtr, len(ctx.items_received)))
             await snes_flush_writes(ctx)
         elif ctx.game == GAME_SMZ3:
+            if ctx.server is None or ctx.slot is None:
+                # not successfully connected to a multiworld server, cannot process the game sending items
+                continue
             currentGame = await snes_read(ctx, SRAM_START + 0x33FE, 2)
             if (currentGame is not None):
                 if (currentGame[0] != 0):
@@ -1260,7 +1268,8 @@ async def game_watcher(ctx: Context):
                 snes_buffered_write(ctx, SMZ3_RECV_PROGRESS_ADDR + 0x680, bytes([recv_index & 0xFF, (recv_index >> 8) & 0xFF]))
 
                 from worlds.smz3.TotalSMZ3.Location import locations_start_id
-                location_id = locations_start_id + itemIndex
+                from worlds.smz3 import convertLocSMZ3IDToAPID
+                location_id = locations_start_id + convertLocSMZ3IDToAPID(itemIndex)
 
                 ctx.locations_checked.add(location_id)
                 location = ctx.location_names[location_id]

Starcraft2Client.py

@@ -1,31 +1,32 @@
 from __future__ import annotations
 
-import multiprocessing
-import logging
 import asyncio
+import copy
+import ctypes
+import logging
+import multiprocessing
 import os.path
+import re
+import sys
+import typing
+import queue
+from pathlib import Path
 
 import nest_asyncio
 import sc2
-
-from sc2.main import run_game
-from sc2.data import Race
 from sc2.bot_ai import BotAI
+from sc2.data import Race
+from sc2.main import run_game
 from sc2.player import Bot
 
-from worlds.sc2wol.Regions import MissionInfo
-from worlds.sc2wol.MissionTables import lookup_id_to_mission
-from worlds.sc2wol.Items import lookup_id_to_name, item_table
-from worlds.sc2wol.Locations import SC2WOL_LOC_ID_OFFSET
-from worlds.sc2wol import SC2WoLWorld
-
-from pathlib import Path
-import re
+import NetUtils
 from MultiServer import mark_raw
-import ctypes
-import sys
-
 from Utils import init_logging, is_windows
+from worlds.sc2wol import SC2WoLWorld
+from worlds.sc2wol.Items import lookup_id_to_name, item_table, ItemData, type_flaggroups
+from worlds.sc2wol.Locations import SC2WOL_LOC_ID_OFFSET
+from worlds.sc2wol.MissionTables import lookup_id_to_mission
+from worlds.sc2wol.Regions import MissionInfo
 
 if __name__ == "__main__":
     init_logging("SC2Client", exception_logger="Client")
@@ -35,10 +36,12 @@ sc2_logger = logging.getLogger("Starcraft2")
 
 import colorama
 
-from NetUtils import *
+from NetUtils import ClientStatus, RawJSONtoTextParser
 from CommonClient import CommonContext, server_loop, ClientCommandProcessor, gui_enabled, get_base_parser
 
 nest_asyncio.apply()
+max_bonus: int = 8
+victory_modulo: int = 100
 
 
 class StarcraftClientProcessor(ClientCommandProcessor):
@@ -98,13 +101,13 @@ class StarcraftClientProcessor(ClientCommandProcessor):
     def _cmd_available(self) -> bool:
         """Get what missions are currently available to play"""
 
-        request_available_missions(self.ctx.checked_locations, self.ctx.mission_req_table, self.ctx.ui)
+        request_available_missions(self.ctx)
         return True
 
     def _cmd_unfinished(self) -> bool:
         """Get what missions are currently available to play and have not had all locations checked"""
 
-        request_unfinished_missions(self.ctx.checked_locations, self.ctx.mission_req_table, self.ctx.ui, self.ctx)
+        request_unfinished_missions(self.ctx)
         return True
 
     @mark_raw
@@ -125,18 +128,19 @@ class SC2Context(CommonContext):
     items_handling = 0b111
     difficulty = -1
     all_in_choice = 0
-    mission_req_table = None
-    items_rec_to_announce = []
-    rec_announce_pos = 0
-    items_sent_to_announce = []
-    sent_announce_pos = 0
-    announcements = []
-    announcement_pos = 0
+    mission_req_table: typing.Dict[str, MissionInfo] = {}
+    announcements = queue.Queue()
     sc2_run_task: typing.Optional[asyncio.Task] = None
-    missions_unlocked = False
+    missions_unlocked: bool = False  # allow launching missions ignoring requirements
     current_tooltip = None
     last_loc_list = None
     difficulty_override = -1
+    mission_id_to_location_ids: typing.Dict[int, typing.List[int]] = {}
+    last_bot: typing.Optional[ArchipelagoBot] = None
+
+    def __init__(self, *args, **kwargs):
+        super(SC2Context, self).__init__(*args, **kwargs)
+        self.raw_text_parser = RawJSONtoTextParser(self)
 
     async def server_auth(self, password_requested: bool = False):
         if password_requested and not self.password:
@@ -149,30 +153,35 @@ class SC2Context(CommonContext):
             self.difficulty = args["slot_data"]["game_difficulty"]
             self.all_in_choice = args["slot_data"]["all_in_map"]
             slot_req_table = args["slot_data"]["mission_req"]
-            self.mission_req_table = {}
-            # Compatibility for 0.3.2 server data.
-            if "category" not in next(iter(slot_req_table)):
-                for i, mission_data in enumerate(slot_req_table.values()):
-                    mission_data["category"] = wol_default_categories[i]
-            for mission in slot_req_table:
-                self.mission_req_table[mission] = MissionInfo(**slot_req_table[mission])
+            self.mission_req_table = {
+                mission: MissionInfo(**slot_req_table[mission]) for mission in slot_req_table
+            }
+
+            self.build_location_to_mission_mapping()
 
             # Look for and set SC2PATH.
             # check_game_install_path() returns True if and only if it finds + sets SC2PATH.
             if "SC2PATH" not in os.environ and check_game_install_path():
                 check_mod_install()
 
-        if cmd in {"PrintJSON"}:
-            if "receiving" in args:
-                if self.slot_concerns_self(args["receiving"]):
-                    self.announcements.append(args["data"])
-                    return
-            if "item" in args:
-                if self.slot_concerns_self(args["item"].player):
-                    self.announcements.append(args["data"])
+    def on_print_json(self, args: dict):
+        # goes to this world
+        if "receiving" in args and self.slot_concerns_self(args["receiving"]):
+            relevant = True
+        # found in this world
+        elif "item" in args and self.slot_concerns_self(args["item"].player):
+            relevant = True
+        # not related
+        else:
+            relevant = False
+
+        if relevant:
+            self.announcements.put(self.raw_text_parser(copy.deepcopy(args["data"])))
+
+        super(SC2Context, self).on_print_json(args)
 
     def run_gui(self):
-        from kvui import GameManager, HoverBehavior, ServerToolTip, fade_in_animation
+        from kvui import GameManager, HoverBehavior, ServerToolTip
         from kivy.app import App
         from kivy.clock import Clock
         from kivy.uix.tabbedpanel import TabbedPanelItem
@@ -190,6 +199,7 @@ class SC2Context(CommonContext):
 
         class MissionButton(HoverableButton):
             tooltip_text = StringProperty("Test")
+            ctx: SC2Context
 
             def __init__(self, *args, **kwargs):
                 super(HoverableButton, self).__init__(*args, **kwargs)
@@ -210,10 +220,7 @@ class SC2Context(CommonContext):
                     self.ctx.current_tooltip = self.layout
 
             def on_leave(self):
-                if self.ctx.current_tooltip:
-                    App.get_running_app().root.remove_widget(self.ctx.current_tooltip)
-
-                self.ctx.current_tooltip = None
+                self.ctx.ui.clear_tooltip()
 
             @property
             def ctx(self) -> CommonContext:
@@ -235,13 +242,20 @@ class SC2Context(CommonContext):
             mission_panel = None
             last_checked_locations = {}
             mission_id_to_button = {}
-            launching = False
+            launching: typing.Union[bool, int] = False  # if int -> mission ID
             refresh_from_launching = True
             first_check = True
+            ctx: SC2Context
 
             def __init__(self, ctx):
                 super().__init__(ctx)
 
+            def clear_tooltip(self):
+                if self.ctx.current_tooltip:
+                    App.get_running_app().root.remove_widget(self.ctx.current_tooltip)
+
+                self.ctx.current_tooltip = None
+
             def build(self):
                 container = super().build()
 
@@ -256,7 +270,7 @@ class SC2Context(CommonContext):
 
             def build_mission_table(self, dt):
                 if (not self.launching and (not self.last_checked_locations == self.ctx.checked_locations or
-                                           not self.refresh_from_launching)) or self.first_check:
+                                            not self.refresh_from_launching)) or self.first_check:
                     self.refresh_from_launching = True
 
                     self.mission_panel.clear_widgets()
@@ -267,12 +281,7 @@ class SC2Context(CommonContext):
 
                         self.mission_id_to_button = {}
                         categories = {}
-                        available_missions = []
-                        unfinished_locations = initialize_blank_mission_dict(self.ctx.mission_req_table)
-                        unfinished_missions = calc_unfinished_missions(self.ctx.checked_locations,
-                                                                       self.ctx.mission_req_table,
-                                                                       self.ctx, available_missions=available_missions,
-                                                                       unfinished_locations=unfinished_locations)
+                        available_missions, unfinished_missions = calc_unfinished_missions(self.ctx)
 
                         # separate missions into categories
                         for mission in self.ctx.mission_req_table:
@@ -283,34 +292,40 @@ class SC2Context(CommonContext):
 
                         for category in categories:
                             category_panel = MissionCategory()
-                            category_panel.add_widget(Label(text=category, size_hint_y=None, height=50, outline_width=1))
+                            category_panel.add_widget(
+                                Label(text=category, size_hint_y=None, height=50, outline_width=1))
 
-                            # Map is completed
                             for mission in categories[category]:
-                                text = mission
-                                tooltip = ""
+                                text: str = mission
+                                tooltip: str = ""
 
                                 # Map has uncollected locations
                                 if mission in unfinished_missions:
                                     text = f"[color=6495ED]{text}[/color]"
 
-                                    tooltip = f"Uncollected locations:\n"
-                                    tooltip += "\n".join(location for location in unfinished_locations[mission])
                                 elif mission in available_missions:
                                     text = f"[color=FFFFFF]{text}[/color]"
                                 # Map requirements not met
                                 else:
                                     text = f"[color=a9a9a9]{text}[/color]"
                                     tooltip = f"Requires: "
-                                    if len(self.ctx.mission_req_table[mission].required_world) > 0:
-                                        tooltip += ", ".join(list(self.ctx.mission_req_table)[req_mission-1] for
+                                    if self.ctx.mission_req_table[mission].required_world:
+                                        tooltip += ", ".join(list(self.ctx.mission_req_table)[req_mission - 1] for
                                                              req_mission in
                                                              self.ctx.mission_req_table[mission].required_world)
 
-                                        if self.ctx.mission_req_table[mission].number > 0:
+                                        if self.ctx.mission_req_table[mission].number:
                                             tooltip += " and "
-                                    if self.ctx.mission_req_table[mission].number > 0:
+                                    if self.ctx.mission_req_table[mission].number:
                                         tooltip += f"{self.ctx.mission_req_table[mission].number} missions completed"
+                                remaining_location_names: typing.List[str] = [
+                                    self.ctx.location_names[loc] for loc in self.ctx.locations_for_mission(mission)
+                                    if loc in self.ctx.missing_locations]
+                                if remaining_location_names:
+                                    if tooltip:
+                                        tooltip += "\n"
+                                    tooltip += f"Uncollected locations:\n"
+                                    tooltip += "\n".join(remaining_location_names)
 
                                 mission_button = MissionButton(text=text, size_hint_y=None, height=50)
                                 mission_button.tooltip_text = tooltip
@@ -325,13 +340,16 @@ class SC2Context(CommonContext):
                     self.refresh_from_launching = False
 
                     self.mission_panel.clear_widgets()
-                    self.mission_panel.add_widget(Label(text="Launching Mission"))
+                    self.mission_panel.add_widget(Label(text="Launching Mission: " +
+                                                             lookup_id_to_mission[self.launching]))
+                    if self.ctx.ui:
+                        self.ctx.ui.clear_tooltip()
 
             def mission_callback(self, button):
                 if not self.launching:
-                    self.ctx.play_mission(list(self.mission_id_to_button.keys())
-                                          [list(self.mission_id_to_button.values()).index(button)])
-                    self.launching = True
+                    mission_id: int = next(k for k, v in self.mission_id_to_button.items() if v == button)
+                    self.ctx.play_mission(mission_id)
+                    self.launching = mission_id
                     Clock.schedule_once(self.finish_launching, 10)
 
             def finish_launching(self, dt):
@@ -344,12 +362,14 @@ class SC2Context(CommonContext):
 
     async def shutdown(self):
         await super(SC2Context, self).shutdown()
+        if self.last_bot:
+            self.last_bot.want_close = True
         if self.sc2_run_task:
             self.sc2_run_task.cancel()
 
-    def play_mission(self, mission_id):
+    def play_mission(self, mission_id: int):
         if self.missions_unlocked or \
-                is_mission_available(mission_id, self.checked_locations, self.mission_req_table):
+                is_mission_available(self, mission_id):
             if self.sc2_run_task:
                 if not self.sc2_run_task.done():
                     sc2_logger.warning("Starcraft 2 Client is still running!")
@@ -358,12 +378,29 @@ class SC2Context(CommonContext):
                 sc2_logger.warning("Launching Mission without Archipelago authentication, "
                                    "checks will not be registered to server.")
             self.sc2_run_task = asyncio.create_task(starcraft_launch(self, mission_id),
-                                                        name="Starcraft 2 Launch")
+                                                    name="Starcraft 2 Launch")
         else:
             sc2_logger.info(
                 f"{lookup_id_to_mission[mission_id]} is not currently unlocked.  "
                 f"Use /unfinished or /available to see what is available.")
 
+    def build_location_to_mission_mapping(self):
+        mission_id_to_location_ids: typing.Dict[int, typing.Set[int]] = {
+            mission_info.id: set() for mission_info in self.mission_req_table.values()
+        }
+
+        for loc in self.server_locations:
+            mission_id, objective = divmod(loc - SC2WOL_LOC_ID_OFFSET, victory_modulo)
+            mission_id_to_location_ids[mission_id].add(objective)
+        self.mission_id_to_location_ids = {mission_id: sorted(objectives) for mission_id, objectives in
+                                           mission_id_to_location_ids.items()}
+
+    def locations_for_mission(self, mission: str):
+        mission_id: int = self.mission_req_table[mission].id
+        objectives = self.mission_id_to_location_ids[self.mission_req_table[mission].id]
+        for objective in objectives:
+            yield SC2WOL_LOC_ID_OFFSET + mission_id * 100 + objective
+
 
 async def main():
     multiprocessing.freeze_support()
@@ -403,47 +440,27 @@ wol_default_categories = [
 ]
 
 
-def calculate_items(items):
-    unit_unlocks = 0
-    armory1_unlocks = 0
-    armory2_unlocks = 0
-    upgrade_unlocks = 0
-    building_unlocks = 0
-    merc_unlocks = 0
-    lab_unlocks = 0
-    protoss_unlock = 0
-    minerals = 0
-    vespene = 0
-    supply = 0
+def calculate_items(items: typing.List[NetUtils.NetworkItem]) -> typing.List[int]:
+    network_item: NetUtils.NetworkItem
+    accumulators: typing.List[int] = [0 for _ in type_flaggroups]
 
-    for item in items:
-        data = lookup_id_to_name[item.item]
+    for network_item in items:
+        name: str = lookup_id_to_name[network_item.item]
+        item_data: ItemData = item_table[name]
 
-        if item_table[data].type == "Unit":
-            unit_unlocks += (1 << item_table[data].number)
-        elif item_table[data].type == "Upgrade":
-            upgrade_unlocks += (1 << item_table[data].number)
-        elif item_table[data].type == "Armory 1":
-            armory1_unlocks += (1 << item_table[data].number)
-        elif item_table[data].type == "Armory 2":
-            armory2_unlocks += (1 << item_table[data].number)
-        elif item_table[data].type == "Building":
-            building_unlocks += (1 << item_table[data].number)
-        elif item_table[data].type == "Mercenary":
-            merc_unlocks += (1 << item_table[data].number)
-        elif item_table[data].type == "Laboratory":
-            lab_unlocks += (1 << item_table[data].number)
-        elif item_table[data].type == "Protoss":
-            protoss_unlock += (1 << item_table[data].number)
-        elif item_table[data].type == "Minerals":
-            minerals += item_table[data].number
-        elif item_table[data].type == "Vespene":
-            vespene += item_table[data].number
-        elif item_table[data].type == "Supply":
-            supply += item_table[data].number
+        # exists exactly once
+        if item_data.quantity == 1:
+            accumulators[type_flaggroups[item_data.type]] |= 1 << item_data.number
 
-    return [unit_unlocks, upgrade_unlocks, armory1_unlocks, armory2_unlocks, building_unlocks, merc_unlocks,
-            lab_unlocks, protoss_unlock, minerals, vespene, supply]
+        # exists multiple times
+        elif item_data.type == "Upgrade":
+            accumulators[type_flaggroups[item_data.type]] += 1 << item_data.number
+
+        # sum
+        else:
+            accumulators[type_flaggroups[item_data.type]] += item_data.number
+
+    return accumulators
 
 
 def calc_difficulty(difficulty):
@@ -459,11 +476,7 @@ def calc_difficulty(difficulty):
     return 'X'
 
 
-async def starcraft_launch(ctx: SC2Context, mission_id):
-    ctx.rec_announce_pos = len(ctx.items_rec_to_announce)
-    ctx.sent_announce_pos = len(ctx.items_sent_to_announce)
-    ctx.announcements_pos = len(ctx.announcements)
-
+async def starcraft_launch(ctx: SC2Context, mission_id: int):
     sc2_logger.info(f"Launching {lookup_id_to_mission[mission_id]}. If game does not launch check log file for errors.")
 
     with DllDirectory(None):
@@ -472,32 +485,34 @@ async def starcraft_launch(ctx: SC2Context, mission_id):
 
 
 class ArchipelagoBot(sc2.bot_ai.BotAI):
-    game_running = False
-    mission_completed = False
-    first_bonus = False
-    second_bonus = False
-    third_bonus = False
-    fourth_bonus = False
-    fifth_bonus = False
-    sixth_bonus = False
-    seventh_bonus = False
-    eight_bonus = False
-    ctx: SC2Context = None
-    mission_id = 0
-
+    game_running: bool = False
+    mission_completed: bool = False
+    boni: typing.List[bool]
+    setup_done: bool
+    ctx: SC2Context
+    mission_id: int
+    want_close: bool = False
     can_read_game = False
 
-    last_received_update = 0
+    last_received_update: int = 0
 
     def __init__(self, ctx: SC2Context, mission_id):
+        self.setup_done = False
         self.ctx = ctx
+        self.ctx.last_bot = self
         self.mission_id = mission_id
+        self.boni = [False for _ in range(max_bonus)]
 
         super(ArchipelagoBot, self).__init__()
 
     async def on_step(self, iteration: int):
+        if self.want_close:
+            self.want_close = False
+            await self._client.leave()
+            return
         game_state = 0
-        if iteration == 0:
+        if not self.setup_done:
+            self.setup_done = True
             start_items = calculate_items(self.ctx.items_received)
             if self.ctx.difficulty_override >= 0:
                 difficulty = calc_difficulty(self.ctx.difficulty_override)
@@ -511,36 +526,10 @@ class ArchipelagoBot(sc2.bot_ai.BotAI):
             self.last_received_update = len(self.ctx.items_received)
 
         else:
-            if self.ctx.announcement_pos < len(self.ctx.announcements):
-                index = 0
-                message = ""
-                while index < len(self.ctx.announcements[self.ctx.announcement_pos]):
-                    message += self.ctx.announcements[self.ctx.announcement_pos][index]["text"]
-                    index += 1
-
-                index = 0
-                start_rem_pos = -1
-                # Remove unneeded [Color] tags
-                while index < len(message):
-                    if message[index] == '[':
-                        start_rem_pos = index
-                        index += 1
-                    elif message[index] == ']' and start_rem_pos > -1:
-                        temp_msg = ""
-
-                        if start_rem_pos > 0:
-                            temp_msg = message[:start_rem_pos]
-                        if index < len(message) - 1:
-                            temp_msg += message[index + 1:]
-
-                        message = temp_msg
-                        index += start_rem_pos - index
-                        start_rem_pos = -1
-                    else:
-                        index += 1
-
+            if not self.ctx.announcements.empty():
+                message = self.ctx.announcements.get(timeout=1)
                 await self.chat_send("SendMessage " + message)
-                self.ctx.announcement_pos += 1
+                self.ctx.announcements.task_done()
 
             # Archipelago reads the health
             for unit in self.all_own_units():
@@ -568,169 +557,97 @@ class ArchipelagoBot(sc2.bot_ai.BotAI):
                     if game_state & (1 << 1) and not self.mission_completed:
                         if self.mission_id != 29:
                             print("Mission Completed")
-                            await self.ctx.send_msgs([
-                                {"cmd": 'LocationChecks', "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id]}])
+                            await self.ctx.send_msgs(
+                                [{"cmd": 'LocationChecks',
+                                  "locations": [SC2WOL_LOC_ID_OFFSET + victory_modulo * self.mission_id]}])
                             self.mission_completed = True
                         else:
                             print("Game Complete")
                             await self.ctx.send_msgs([{"cmd": 'StatusUpdate', "status": ClientStatus.CLIENT_GOAL}])
                             self.mission_completed = True
 
-                    if game_state & (1 << 2) and not self.first_bonus:
-                        print("1st Bonus Collected")
-                        await self.ctx.send_msgs(
-                            [{"cmd": 'LocationChecks',
-                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 1]}])
-                        self.first_bonus = True
-
-                    if not self.second_bonus and game_state & (1 << 3):
-                        print("2nd Bonus Collected")
-                        await self.ctx.send_msgs(
-                            [{"cmd": 'LocationChecks',
-                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 2]}])
-                        self.second_bonus = True
-
-                    if not self.third_bonus and game_state & (1 << 4):
-                        print("3rd Bonus Collected")
-                        await self.ctx.send_msgs(
-                            [{"cmd": 'LocationChecks',
-                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 3]}])
-                        self.third_bonus = True
-
-                    if not self.fourth_bonus and game_state & (1 << 5):
-                        print("4th Bonus Collected")
-                        await self.ctx.send_msgs(
-                            [{"cmd": 'LocationChecks',
-                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 4]}])
-                        self.fourth_bonus = True
-
-                    if not self.fifth_bonus and game_state & (1 << 6):
-                        print("5th Bonus Collected")
-                        await self.ctx.send_msgs(
-                            [{"cmd": 'LocationChecks',
-                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 5]}])
-                        self.fifth_bonus = True
-
-                    if not self.sixth_bonus and game_state & (1 << 7):
-                        print("6th Bonus Collected")
-                        await self.ctx.send_msgs(
-                            [{"cmd": 'LocationChecks',
-                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 6]}])
-                        self.sixth_bonus = True
-
-                    if not self.seventh_bonus and game_state & (1 << 8):
-                        print("6th Bonus Collected")
-                        await self.ctx.send_msgs(
-                            [{"cmd": 'LocationChecks',
-                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 7]}])
-                        self.seventh_bonus = True
-
-                    if not self.eight_bonus and game_state & (1 << 9):
-                        print("6th Bonus Collected")
-                        await self.ctx.send_msgs(
-                            [{"cmd": 'LocationChecks',
-                              "locations": [SC2WOL_LOC_ID_OFFSET + 100 * self.mission_id + 8]}])
-                        self.eight_bonus = True
+                    for x, completed in enumerate(self.boni):
+                        if not completed and game_state & (1 << (x + 2)):
+                            await self.ctx.send_msgs(
+                                [{"cmd": 'LocationChecks',
+                                  "locations": [SC2WOL_LOC_ID_OFFSET + victory_modulo * self.mission_id + x + 1]}])
+                            self.boni[x] = True
 
                 else:
                     await self.chat_send("LostConnection - Lost connection to game.")
 
 
-def calc_objectives_completed(mission, missions_info, locations_done, unfinished_locations, ctx):
-    objectives_complete = 0
-
-    if missions_info[mission].extra_locations > 0:
-        for i in range(missions_info[mission].extra_locations):
-            if (missions_info[mission].id * 100 + SC2WOL_LOC_ID_OFFSET + i) in locations_done:
-                objectives_complete += 1
-            else:
-                unfinished_locations[mission].append(ctx.location_names[
-                    missions_info[mission].id * 100 + SC2WOL_LOC_ID_OFFSET + i])
-
-        return objectives_complete
-
-    else:
-        return -1
-
-
-def request_unfinished_missions(locations_done, location_table, ui, ctx):
-    if location_table:
+def request_unfinished_missions(ctx: SC2Context):
+    if ctx.mission_req_table:
         message = "Unfinished Missions: "
-        unlocks = initialize_blank_mission_dict(location_table)
-        unfinished_locations = initialize_blank_mission_dict(location_table)
+        unlocks = initialize_blank_mission_dict(ctx.mission_req_table)
+        unfinished_locations = initialize_blank_mission_dict(ctx.mission_req_table)
 
-        unfinished_missions = calc_unfinished_missions(locations_done, location_table, ctx, unlocks=unlocks,
-                                                       unfinished_locations=unfinished_locations)
+        _, unfinished_missions = calc_unfinished_missions(ctx, unlocks=unlocks)
 
-        message += ", ".join(f"{mark_up_mission_name(mission, location_table, ui,unlocks)}[{location_table[mission].id}] " +
+        message += ", ".join(f"{mark_up_mission_name(ctx, mission, unlocks)}[{ctx.mission_req_table[mission].id}] " +
                              mark_up_objectives(
-                                 f"[{unfinished_missions[mission]}/{location_table[mission].extra_locations}]",
+                                 f"[{len(unfinished_missions[mission])}/"
+                                 f"{sum(1 for _ in ctx.locations_for_mission(mission))}]",
                                  ctx, unfinished_locations, mission)
                              for mission in unfinished_missions)
 
-        if ui:
-            ui.log_panels['All'].on_message_markup(message)
-            ui.log_panels['Starcraft2'].on_message_markup(message)
+        if ctx.ui:
+            ctx.ui.log_panels['All'].on_message_markup(message)
+            ctx.ui.log_panels['Starcraft2'].on_message_markup(message)
         else:
             sc2_logger.info(message)
     else:
         sc2_logger.warning("No mission table found, you are likely not connected to a server.")
 
 
-def calc_unfinished_missions(locations_done, locations, ctx, unlocks=None, unfinished_locations=None,
-                             available_missions=[]):
+def calc_unfinished_missions(ctx: SC2Context, unlocks=None):
     unfinished_missions = []
     locations_completed = []
 
     if not unlocks:
-        unlocks = initialize_blank_mission_dict(locations)
+        unlocks = initialize_blank_mission_dict(ctx.mission_req_table)
 
-    if not unfinished_locations:
-        unfinished_locations = initialize_blank_mission_dict(locations)
-
-    if len(available_missions) > 0:
-        available_missions = []
-
-    available_missions.extend(calc_available_missions(locations_done, locations, unlocks))
+    available_missions = calc_available_missions(ctx, unlocks)
 
     for name in available_missions:
-        if not locations[name].extra_locations == -1:
-            objectives_completed = calc_objectives_completed(name, locations, locations_done, unfinished_locations, ctx)
-
-            if objectives_completed < locations[name].extra_locations:
+        objectives = set(ctx.locations_for_mission(name))
+        if objectives:
+            objectives_completed = ctx.checked_locations & objectives
+            if len(objectives_completed) < len(objectives):
                 unfinished_missions.append(name)
                 locations_completed.append(objectives_completed)
 
-        else:
+        else:  # infer that this is the final mission as it has no objectives
             unfinished_missions.append(name)
             locations_completed.append(-1)
 
-    return {unfinished_missions[i]: locations_completed[i] for i in range(len(unfinished_missions))}
+    return available_missions, dict(zip(unfinished_missions, locations_completed))
 
 
-def is_mission_available(mission_id_to_check, locations_done, locations):
-    unfinished_missions = calc_available_missions(locations_done, locations)
+def is_mission_available(ctx: SC2Context, mission_id_to_check):
+    unfinished_missions = calc_available_missions(ctx)
 
-    return any(mission_id_to_check == locations[mission].id for mission in unfinished_missions)
+    return any(mission_id_to_check == ctx.mission_req_table[mission].id for mission in unfinished_missions)
 
 
-def mark_up_mission_name(mission, location_table, ui, unlock_table):
+def mark_up_mission_name(ctx: SC2Context, mission, unlock_table):
     """Checks if the mission is required for game completion and adds '*' to the name to mark that."""
 
-    if location_table[mission].completion_critical:
-        if ui:
+    if ctx.mission_req_table[mission].completion_critical:
+        if ctx.ui:
             message = "[color=AF99EF]" + mission + "[/color]"
         else:
             message = "*" + mission + "*"
     else:
         message = mission
 
-    if ui:
+    if ctx.ui:
         unlocks = unlock_table[mission]
 
         if len(unlocks) > 0:
-            pre_message = f"[ref={list(location_table).index(mission)}|Unlocks: "
-            pre_message += ", ".join(f"{unlock}({location_table[unlock].id})" for unlock in unlocks)
+            pre_message = f"[ref={list(ctx.mission_req_table).index(mission)}|Unlocks: "
+            pre_message += ", ".join(f"{unlock}({ctx.mission_req_table[unlock].id})" for unlock in unlocks)
             pre_message += f"]"
             message = pre_message + message + "[/ref]"
 
@@ -743,7 +660,7 @@ def mark_up_objectives(message, ctx, unfinished_locations, mission):
     if ctx.ui:
         locations = unfinished_locations[mission]
 
-        pre_message = f"[ref={list(ctx.mission_req_table).index(mission)+30}|"
+        pre_message = f"[ref={list(ctx.mission_req_table).index(mission) + 30}|"
         pre_message += "<br>".join(location for location in locations)
         pre_message += f"]"
         formatted_message = pre_message + message + "[/ref]"
@@ -751,90 +668,91 @@ def mark_up_objectives(message, ctx, unfinished_locations, mission):
     return formatted_message
 
 
-def request_available_missions(locations_done, location_table, ui):
-    if location_table:
+def request_available_missions(ctx: SC2Context):
+    if ctx.mission_req_table:
         message = "Available Missions: "
 
         # Initialize mission unlock table
-        unlocks = initialize_blank_mission_dict(location_table)
+        unlocks = initialize_blank_mission_dict(ctx.mission_req_table)
 
-        missions = calc_available_missions(locations_done, location_table, unlocks)
+        missions = calc_available_missions(ctx, unlocks)
         message += \
-            ", ".join(f"{mark_up_mission_name(mission, location_table, ui, unlocks)}[{location_table[mission].id}]"
+            ", ".join(f"{mark_up_mission_name(ctx, mission, unlocks)}"
+                      f"[{ctx.mission_req_table[mission].id}]"
                       for mission in missions)
 
-        if ui:
-            ui.log_panels['All'].on_message_markup(message)
-            ui.log_panels['Starcraft2'].on_message_markup(message)
+        if ctx.ui:
+            ctx.ui.log_panels['All'].on_message_markup(message)
+            ctx.ui.log_panels['Starcraft2'].on_message_markup(message)
         else:
             sc2_logger.info(message)
     else:
         sc2_logger.warning("No mission table found, you are likely not connected to a server.")
 
 
-def calc_available_missions(locations_done, locations, unlocks=None):
+def calc_available_missions(ctx: SC2Context, unlocks=None):
     available_missions = []
     missions_complete = 0
 
     # Get number of missions completed
-    for loc in locations_done:
-        if loc % 100 == 0:
+    for loc in ctx.checked_locations:
+        if loc % victory_modulo == 0:
             missions_complete += 1
 
-    for name in locations:
+    for name in ctx.mission_req_table:
         # Go through the required missions for each mission and fill up unlock table used later for hover-over tooltips
         if unlocks:
-            for unlock in locations[name].required_world:
-                unlocks[list(locations)[unlock-1]].append(name)
+            for unlock in ctx.mission_req_table[name].required_world:
+                unlocks[list(ctx.mission_req_table)[unlock - 1]].append(name)
 
-        if mission_reqs_completed(name, missions_complete, locations_done, locations):
+        if mission_reqs_completed(ctx, name, missions_complete):
             available_missions.append(name)
 
     return available_missions
 
 
-def mission_reqs_completed(location_to_check, missions_complete, locations_done, locations):
+def mission_reqs_completed(ctx: SC2Context, mission_name: str, missions_complete):
     """Returns a bool signifying if the mission has all requirements complete and can be done
 
-    Keyword arguments:
+    Arguments:
+    ctx -- instance of SC2Context
     locations_to_check -- the mission string name to check
     missions_complete -- an int of how many missions have been completed
-    locations_done -- a list of the location ids that have been complete
-    locations -- a dict of MissionInfo for mission requirements for this world"""
-    if len(locations[location_to_check].required_world) >= 1:
+"""
+    if len(ctx.mission_req_table[mission_name].required_world) >= 1:
         # A check for when the requirements are being or'd
         or_success = False
 
         # Loop through required missions
-        for req_mission in locations[location_to_check].required_world:
+        for req_mission in ctx.mission_req_table[mission_name].required_world:
             req_success = True
 
             # Check if required mission has been completed
-            if not (locations[list(locations)[req_mission-1]].id * 100 + SC2WOL_LOC_ID_OFFSET) in locations_done:
-                if not locations[location_to_check].or_requirements:
+            if not (ctx.mission_req_table[list(ctx.mission_req_table)[req_mission - 1]].id *
+                    victory_modulo + SC2WOL_LOC_ID_OFFSET) in ctx.checked_locations:
+                if not ctx.mission_req_table[mission_name].or_requirements:
                     return False
                 else:
                     req_success = False
 
             # Recursively check required mission to see if it's requirements are met, in case !collect has been done
-            if not mission_reqs_completed(list(locations)[req_mission-1], missions_complete, locations_done,
-                                          locations):
-                if not locations[location_to_check].or_requirements:
+            if not mission_reqs_completed(ctx, list(ctx.mission_req_table)[req_mission - 1], missions_complete):
+                if not ctx.mission_req_table[mission_name].or_requirements:
                     return False
                 else:
                     req_success = False
 
             # If requirement check succeeded mark or as satisfied
-            if locations[location_to_check].or_requirements and req_success:
+            if ctx.mission_req_table[mission_name].or_requirements and req_success:
                 or_success = True
 
-        if locations[location_to_check].or_requirements:
+        if ctx.mission_req_table[mission_name].or_requirements:
             # Return false if or requirements not met
             if not or_success:
                 return False
 
         # Check number of missions
-        if missions_complete >= locations[location_to_check].number:
+        if missions_complete >= ctx.mission_req_table[mission_name].number:
             return True
         else:
             return False
@@ -875,7 +793,12 @@ def check_game_install_path() -> bool:
         with open(einfo) as f:
             content = f.read()
         if content:
-            base = re.search(r" = (.*)Versions", content).group(1)
+            try:
+                base = re.search(r" = (.*)Versions", content).group(1)
+            except AttributeError:
+                sc2_logger.warning(f"Found {einfo}, but it was empty. Run SC2 through the Blizzard launcher, then "
+                                   f"try again.")
+                return False
             if os.path.exists(base):
                 executable = sc2.paths.latest_executeble(Path(base).expanduser() / "Versions")
 
@@ -892,7 +815,8 @@ def check_game_install_path() -> bool:
             else:
                 sc2_logger.warning(f"{einfo} pointed to {base}, but we could not find an SC2 install there.")
     else:
-        sc2_logger.warning(f"Couldn't find {einfo}. Please run /set_path with your SC2 install directory.")
+        sc2_logger.warning(f"Couldn't find {einfo}. Run SC2 through the Blizzard launcher, then try again. "
+                           f"If that fails, please run /set_path with your SC2 install directory.")
     return False
 
 
@@ -929,7 +853,7 @@ class DllDirectory:
             self.set(self._old)
 
     @staticmethod
-    def get() -> str:
+    def get() -> typing.Optional[str]:
         if sys.platform == "win32":
             n = ctypes.windll.kernel32.GetDllDirectoryW(0, None)
             buf = ctypes.create_unicode_buffer(n)

Utils.py

@@ -35,7 +35,7 @@ class Version(typing.NamedTuple):
     build: int
 
 
-__version__ = "0.3.4"
+__version__ = "0.3.5"
 version_tuple = tuplize_version(__version__)
 
 is_linux = sys.platform.startswith("linux")
@@ -619,7 +619,7 @@ def title_sorted(data: typing.Sequence, key=None, ignore: typing.Set = frozenset
     def sorter(element: str) -> str:
         parts = element.split(maxsplit=1)
         if parts[0].lower() in ignore:
-            return parts[1]
+            return parts[1].lower()
         else:
-            return element
+            return element.lower()
     return sorted(data, key=lambda i: sorter(key(i)) if key else sorter(i))

WebHost.py

@@ -12,7 +12,7 @@ ModuleUpdate.update()
 # in case app gets imported by something like gunicorn
 import Utils
 
-Utils.local_path.cached_path = os.path.dirname(__file__)
+Utils.local_path.cached_path = os.path.dirname(__file__) or "."  # py3.8 is not abs. remove "." when dropping 3.8
 
 from WebHostLib import register, app as raw_app
 from waitress import serve
@@ -104,7 +104,7 @@ def create_ordered_tutorials_file() -> typing.List[typing.Dict[str, typing.Any]]
         for games in data:
             if 'Archipelago' in games['gameTitle']:
                 generic_data = data.pop(data.index(games))
-        sorted_data = [generic_data] + Utils.title_sorted(data, key=lambda entry: entry["gameTitle"].lower())
+        sorted_data = [generic_data] + Utils.title_sorted(data, key=lambda entry: entry["gameTitle"])
         json.dump(sorted_data, json_target, indent=2, ensure_ascii=False)
     return sorted_data
 

WebHostLib/customserver.py

@@ -1,15 +1,16 @@
 from __future__ import annotations
 
-import functools
-import websockets
 import asyncio
+import collections
+import datetime
+import functools
+import logging
+import pickle
+import random
 import socket
 import threading
 import time
-import random
-import pickle
-import logging
-import datetime
+import websockets
 
 import Utils
 from .models import db_session, Room, select, commit, Command, db
@@ -49,6 +50,8 @@ class DBCommandProcessor(ServerCommandProcessor):
 
 
 class WebHostContext(Context):
+    room_id: int
+
     def __init__(self, static_server_data: dict):
         # static server data is used during _load_game_data to load required data,
         # without needing to import worlds system, which takes quite a bit of memory
@@ -62,6 +65,8 @@ class WebHostContext(Context):
     def _load_game_data(self):
         for key, value in self.static_server_data.items():
             setattr(self, key, value)
+        self.forced_auto_forfeits = collections.defaultdict(lambda: False, self.forced_auto_forfeits)
+        self.non_hintable_names = collections.defaultdict(frozenset, self.non_hintable_names)
 
     def listen_to_db_commands(self):
         cmdprocessor = DBCommandProcessor(self)
@@ -103,7 +108,7 @@ class WebHostContext(Context):
         room.multisave = pickle.dumps(self.get_save())
         # saving only occurs on activity, so we can "abuse" this information to mark this as last_activity
         if not exit_save:  # we don't want to count a shutdown as activity, which would restart the server again
-            room.last_activity = datetime.utcnow()
+            room.last_activity = datetime.datetime.utcnow()
         return True
 
     def get_save(self) -> dict:

WebHostLib/downloads.py

@@ -32,9 +32,12 @@ def download_patch(room_id, patch_id):
                             new_zip.writestr("archipelago.json", json.dumps(manifest))
                         else:
                             new_zip.writestr(file.filename, zf.read(file), file.compress_type, 9)
-
+            if "patch_file_ending" in manifest:
+                patch_file_ending = manifest["patch_file_ending"]
+            else:
+                patch_file_ending = AutoPatchRegister.patch_types[patch.game].patch_file_ending
             fname = f"P{patch.player_id}_{patch.player_name}_{app.jinja_env.filters['suuid'](room_id)}" \
-                    f"{AutoPatchRegister.patch_types[patch.game].patch_file_ending}"
+                    f"{patch_file_ending}"
             new_file.seek(0)
             return send_file(new_file, as_attachment=True, download_name=fname)
         else:

WebHostLib/options.py

@@ -1,6 +1,6 @@
 import logging
 import os
-from Utils import __version__
+from Utils import __version__, local_path
 from jinja2 import Template
 import yaml
 import json
@@ -9,14 +9,13 @@ import typing
 from worlds.AutoWorld import AutoWorldRegister
 import Options
 
-target_folder = os.path.join("WebHostLib", "static", "generated")
-
 handled_in_js = {"start_inventory", "local_items", "non_local_items", "start_hints", "start_location_hints",
                  "exclude_locations"}
 
 
 def create():
-    os.makedirs(os.path.join(target_folder, 'configs'), exist_ok=True)
+    target_folder = local_path("WebHostLib", "static", "generated")
+    os.makedirs(os.path.join(target_folder, "configs"), exist_ok=True)
 
     def dictify_range(option: typing.Union[Options.Range, Options.SpecialRange]):
         data = {}
@@ -49,6 +48,11 @@ def create():
             return list(default_value)
         return default_value
 
+    def get_html_doc(option_type: type(Options.Option)) -> str:
+        if not option_type.__doc__:
+            return "Please document me!"
+        return "\n".join(line.strip() for line in option_type.__doc__.split("\n")).strip()
+
     weighted_settings = {
         "baseOptions": {
             "description": "Generated by https://archipelago.gg/",
@@ -61,12 +65,16 @@ def create():
     for game_name, world in AutoWorldRegister.world_types.items():
 
         all_options = {**Options.per_game_common_options, **world.option_definitions}
-        res = Template(open(os.path.join("WebHostLib", "templates", "options.yaml")).read()).render(
+        with open(local_path("WebHostLib", "templates", "options.yaml")) as f:
+            file_data = f.read()
+        res = Template(file_data).render(
             options=all_options,
             __version__=__version__, game=game_name, yaml_dump=yaml.dump,
             dictify_range=dictify_range, default_converter=default_converter,
         )
 
+        del file_data
+
         with open(os.path.join(target_folder, 'configs', game_name + ".yaml"), "w") as f:
             f.write(res)
 
@@ -88,7 +96,7 @@ def create():
                 game_options[option_name] = this_option = {
                     "type": "select",
                     "displayName": option.display_name if hasattr(option, "display_name") else option_name,
-                    "description": option.__doc__ if option.__doc__ else "Please document me!",
+                    "description": get_html_doc(option),
                     "defaultValue": None,
                     "options": []
                 }
@@ -114,7 +122,7 @@ def create():
                 game_options[option_name] = {
                     "type": "range",
                     "displayName": option.display_name if hasattr(option, "display_name") else option_name,
-                    "description": option.__doc__ if option.__doc__ else "Please document me!",
+                    "description": get_html_doc(option),
                     "defaultValue": option.default if hasattr(
                         option, "default") and option.default != "random" else option.range_start,
                     "min": option.range_start,
@@ -131,14 +139,14 @@ def create():
                 game_options[option_name] = {
                     "type": "items-list",
                     "displayName": option.display_name if hasattr(option, "display_name") else option_name,
-                    "description": option.__doc__ if option.__doc__ else "Please document me!",
+                    "description": get_html_doc(option),
                 }
 
             elif getattr(option, "verify_location_name", False):
                 game_options[option_name] = {
                     "type": "locations-list",
                     "displayName": option.display_name if hasattr(option, "display_name") else option_name,
-                    "description": option.__doc__ if option.__doc__ else "Please document me!",
+                    "description": get_html_doc(option),
                 }
 
             elif issubclass(option, Options.OptionList) or issubclass(option, Options.OptionSet):
@@ -146,7 +154,7 @@ def create():
                     game_options[option_name] = {
                         "type": "custom-list",
                         "displayName": option.display_name if hasattr(option, "display_name") else option_name,
-                        "description": option.__doc__ if option.__doc__ else "Please document me!",
+                        "description": get_html_doc(option),
                         "options": list(option.valid_keys),
                     }
 

WebHostLib/requirements.txt

@@ -1,7 +1,7 @@
-flask>=2.1.3
+flask>=2.2.2
 pony>=0.7.16
-waitress>=2.1.1
+waitress>=2.1.2
 Flask-Caching>=2.0.1
 Flask-Compress>=1.12
-Flask-Limiter>=2.5.0
+Flask-Limiter>=2.6.2
 bokeh>=2.4.3

WebHostLib/static/assets/player-settings.js

@@ -102,9 +102,15 @@ const buildOptionsTable = (settings, romOpts = false) => {
     // td Left
     const tdl = document.createElement('td');
     const label = document.createElement('label');
+    label.textContent = `${settings[setting].displayName}: `;
     label.setAttribute('for', setting);
-    label.setAttribute('data-tooltip', settings[setting].description);
-    label.innerText = `${settings[setting].displayName}:`;
+
+    const questionSpan = document.createElement('span');
+    questionSpan.classList.add('interactive');
+    questionSpan.setAttribute('data-tooltip', settings[setting].description);
+    questionSpan.innerText = '(?)';
+
+    label.appendChild(questionSpan);
     tdl.appendChild(label);
     tr.appendChild(tdl);
 

WebHostLib/static/styles/generate.css

@@ -56,7 +56,3 @@
 #file-input{
     display: none;
 }
-
-.interactive{
-    color: #ffef00;
-}

WebHostLib/static/styles/globalStyles.css

@@ -105,3 +105,7 @@ h5, h6{
     margin-bottom: 20px;
     background-color: #ffff00;
 }
+
+.interactive{
+    color: #ffef00;
+}

WebHostLib/static/styles/tooltip.css

@@ -14,7 +14,6 @@ give it one of the following classes: tooltip-left, tooltip-right, tooltip-top,
 /* Base styles for the element that has a tooltip */
 [data-tooltip], .tooltip {
 	position: relative;
-	cursor: pointer;
 }
 
 /* Base styles for the entire tooltip */
@@ -55,14 +54,15 @@ give it one of the following classes: tooltip-left, tooltip-right, tooltip-top,
 
 /** Content styles */
 .tooltip:after, [data-tooltip]:after {
+	width: 260px;
 	z-index: 10000;
 	padding: 8px;
-	width: 160px;
     border-radius: 4px;
 	background-color: #000;
 	background-color: hsla(0, 0%, 20%, 0.9);
 	color: #fff;
 	content: attr(data-tooltip);
+	white-space: pre-wrap;
 	font-size: 14px;
 	line-height: 1.2;
 }

WebHostLib/templates/generate.html

@@ -41,12 +41,11 @@
                             <tbody>
                                 <tr>
                                     <td>
-                                        <label for="forfeit_mode">Forfeit Permission:</label>
-                                        <span
-                                                class="interactive"
-                                                data-tooltip="A forfeit releases all remaining items from the locations
-                                                in your world.">(?)
-                                        </span>
+                                        <label for="forfeit_mode">Forfeit Permission:
+                                            <span class="interactive" data-tooltip="A forfeit releases all remaining items from the locations in your world.">
+                                                (?)
+                                            </span>
+                                        </label>
                                     </td>
                                     <td>
                                         <select name="forfeit_mode" id="forfeit_mode">
@@ -63,12 +62,11 @@
 
                                 <tr>
                                     <td>
-                                        <label for="collect_mode">Collect Permission:</label>
-                                        <span
-                                                class="interactive"
-                                                data-tooltip="A collect releases all of your remaining items to you
-                                                from across the multiworld.">(?)
-                                        </span>
+                                        <label for="collect_mode">Collect Permission:
+                                            <span class="interactive" data-tooltip="A collect releases all of your remaining items to you from across the multiworld.">
+                                                (?)
+                                            </span>
+                                        </label>
                                     </td>
                                     <td>
                                         <select name="collect_mode" id="collect_mode">
@@ -85,12 +83,11 @@
 
                                 <tr>
                                     <td>
-                                        <label for="remaining_mode">Remaining Permission:</label>
-                                        <span
-                                            class="interactive"
-                                            data-tooltip="Remaining lists all items still in your world by name only."
-                                        >(?)
-                                        </span>
+                                        <label for="remaining_mode">Remaining Permission:
+                                            <span class="interactive" data-tooltip="Remaining lists all items still in your world by name only.">
+                                                (?)
+                                            </span>
+                                        </label>
                                     </td>
                                     <td>
                                         <select name="remaining_mode" id="remaining_mode">
@@ -106,11 +103,11 @@
                                 </tr>
                                 <tr>
                                     <td>
-                                        <label for="item_cheat">Item Cheat:</label>
-                                        <span
-                                                class="interactive"
-                                                data-tooltip="Allows players to use the !getitem command.">(?)
-                                        </span>
+                                        <label for="item_cheat">Item Cheat:
+                                            <span class="interactive" data-tooltip="Allows players to use the !getitem command.">
+                                                (?)
+                                            </span>
+                                        </label>
                                     </td>
                                     <td>
                                         <select name="item_cheat" id="item_cheat">
@@ -131,12 +128,11 @@
                                 <tbody>
                                     <tr>
                                         <td>
-                                            <label for="hint_cost"> Hint Cost:</label>
-                                            <span
-                                                class="interactive"
-                                                data-tooltip="After gathering this many checks, players can !hint <itemname>
-                                                to get the location of that hint item.">(?)
-                                            </span>
+                                            <label for="hint_cost"> Hint Cost:
+                                                <span class="interactive" data-tooltip="After gathering this many checks, players can !hint <itemname> to get the location of that hint item.">
+                                                    (?)
+                                                </span>
+                                            </label>
                                         </td>
                                         <td>
                                             <select name="hint_cost" id="hint_cost">
@@ -150,11 +146,11 @@
                                     </tr>
                                     <tr>
                                         <td>
-                                            <label for="server_password">Server Password:</label>
-                                            <span
-                                                class="interactive"
-                                                data-tooltip="Allows for issuing of server console commands from any text client or in-game client using the !admin command.">(?)
-                                            </span>
+                                            <label for="server_password">Server Password:
+                                                <span class="interactive" data-tooltip="Allows for issuing of server console commands from any text client or in-game client using the !admin command.">
+                                                    (?)
+                                                </span>
+                                            </label>
                                         </td>
                                         <td>
                                             <input id="server_password" name="server_password">
@@ -162,23 +158,22 @@
                                     </tr>
                                     <tr>
                                         <td>
-                                            <label for="plando_options">Plando Options:</label>
-                                            <span
-                                                class="interactive"
-                                                data-tooltip="Allows players to plan some of the randomization. See the 'Archipelago Plando Guide' in 'Setup Guides' for more information.">(?)
+                                            Plando Options:
+                                            <span class="interactive" data-tooltip="Allows players to plan some of the randomization. See the 'Archipelago Plando Guide' in 'Setup Guides' for more information.">
+                                                (?)
                                             </span>
                                         </td>
                                         <td>
-                                            <input type="checkbox" name="plando_bosses" value="bosses" checked>
+                                            <input type="checkbox" id="plando_bosses" name="plando_bosses" value="bosses" checked>
                                             <label for="plando_bosses">Bosses</label><br>
 
-                                            <input type="checkbox" name="plando_items" value="items" checked>
+                                            <input type="checkbox" id="plando_items" name="plando_items" value="items" checked>
                                             <label for="plando_items">Items</label><br>
 
-                                            <input type="checkbox" name="plando_connections" value="connections" checked>
+                                            <input type="checkbox" id="plando_connections" name="plando_connections" value="connections" checked>
                                             <label for="plando_connections">Connections</label><br>
 
-                                            <input type="checkbox" name="plando_texts" value="texts" checked>
+                                            <input type="checkbox" id="plando_texts" name="plando_texts" value="texts" checked>
                                             <label for="plando_texts">Text</label>
                                         </td>
                                     </tr>

WebHostLib/templates/islandFooter.html

@@ -6,8 +6,6 @@
             -
             <a href="https://github.com/ArchipelagoMW/Archipelago">Source Code</a>
             -
-            <a href="https://github.com/ArchipelagoMW/Archipelago/wiki">Wiki</a>
-            -
             <a href="https://github.com/ArchipelagoMW/Archipelago/graphs/contributors">Contributors</a>
             -
             <a href="https://github.com/ArchipelagoMW/Archipelago/issues">Bug Report</a>

WebHostLib/templates/supportedGames.html

@@ -1,7 +1,7 @@
 {% extends 'pageWrapper.html' %}
 
 {% block head %}
-    <title>Player Settings</title>
+    <title>Supported Games</title>
     <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/markdown.css") }}" />
     <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/supportedGames.css") }}" />
 {% endblock %}

data/lua/FF1/ff1_connector.lua

@@ -97,6 +97,11 @@ local extensionConsumableLookup = {
     [443] = 0x3F
 }
 
+local noOverworldItemsLookup = {
+    [499] = 0x2B,
+    [500] = 0x12,
+}
+
 local itemMessages = {}
 local consumableStacks = nil
 local prevstate = ""
@@ -341,7 +346,7 @@ function processBlock(block)
                 -- This is a key item
                 memoryLocation = memoryLocation - 0x0E0
                 wU8(memoryLocation, 0x01)
-            elseif v >= 0x1E0 then
+            elseif v >= 0x1E0 and v <= 0x1F2 then
                 -- This is a movement item
                 -- Minus Offset (0x100) - movement offset (0xE0)
                 memoryLocation = memoryLocation - 0x1E0
@@ -351,7 +356,10 @@ function processBlock(block)
                 else
                     wU8(memoryLocation, 0x01)
                 end
-
+            elseif v >= 0x1F3 and v <= 0x1F4 then
+                -- NoOverworld special items
+                memoryLocation = noOverworldItemsLookup[v]
+                wU8(memoryLocation, 0x01)
             elseif v >= 0x16C and v <= 0x1AF then
                 -- This is a gold item
                 amountToAdd = goldLookup[v]

docs/apworld specification.md

@@ -23,3 +23,10 @@ No metadata is specified yet.
 ## Extra Data
 
 The zip can contain arbitrary files in addition what was specified above.
+
+
+## Caveats
+
+Imports from other files inside the apworld have to use relative imports.
+
+Imports from AP base have to use absolute imports, e.g. Options.py and worlds/AutoWorld.py.

docs/code_of_conduct.md

@@ -0,0 +1,11 @@
+# Code of Conduct
+We conduct ourselves openly and inclusively here. Please do not contribute to an environment which makes other people uncomfortable. This means that we expect all contributors or participants here to:
+
+* Be welcoming and inclusive in tone and language.
+* Be respectful of others and their abilities.
+* Show empathy when speaking with others.
+* Be gracious and accept feedback and constructive criticism.
+
+These guidelines apply to all channels of communication within this GitHub repository. Please be respectful in both public channels, such as issues, and private ones, such as private messaging or emails.
+
+Any incidents of abuse may be reported directly to ijwu at hmfarran@gmail.com.

docs/contributing.md

@@ -0,0 +1,12 @@
+# Contributing
+Contributions are welcome. We have a few requests of any new contributors.
+
+* Ensure that all changes which affect logic are covered by unit tests. 
+* Do not introduce any unit test failures/regressions.
+* Follow styling as designated in our [styling documentation](/docs/style.md).
+
+Otherwise, we tend to judge code on a case to case basis.
+
+For adding a new game to Archipelago and other documentation on how Archipelago functions, please see 
+[the docs folder](docs/) for the relevant information and feel free to ask any questions in the #archipelago-dev 
+channel in our [Discord](https://archipelago.gg/discord).

docs/network protocol.md

@@ -13,9 +13,18 @@ These steps should be followed in order to establish a gameplay connection with
 
 In the case that the client does not authenticate properly and receives a [ConnectionRefused](#ConnectionRefused) then the server will maintain the connection and allow for follow-up [Connect](#Connect) packet.
 
-There are libraries available that implement this network protocol in [Python](https://github.com/ArchipelagoMW/Archipelago/blob/main/CommonClient.py), [Java](https://github.com/ArchipelagoMW/Archipelago.MultiClient.Java), [.Net](https://github.com/ArchipelagoMW/Archipelago.MultiClient.Net) and [C++](https://github.com/black-sliver/apclientpp)
+There are also a number of community-supported libraries available that implement this network protocol to make integrating with Archipelago easier.
 
-For Super Nintendo games there are clients available in either [Node](https://github.com/ArchipelagoMW/SuperNintendoClient) or [Python](https://github.com/ArchipelagoMW/Archipelago/blob/main/SNIClient.py), There are also game specific clients available for [The Legend of Zelda: Ocarina of Time](https://github.com/ArchipelagoMW/Z5Client) or [Final Fantasy 1](https://github.com/ArchipelagoMW/Archipelago/blob/main/FF1Client.py)
+| Language/Runtime              | Project                                                                                            | Remarks                                                                         |
+|-------------------------------|----------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------|
+| Python                        | [Archipelago CommonClient](https://github.com/ArchipelagoMW/Archipelago/blob/main/CommonClient.py) |                                                                                 |
+|                               | [Archipelago SNIClient](https://github.com/ArchipelagoMW/Archipelago/blob/main/SNIClient.py)       | For Super Nintendo Game Support; Utilizes [SNI](https://github.com/alttpo/sni). |
+| JVM (Java / Kotlin)           | [Archipelago.MultiClient.Java](https://github.com/ArchipelagoMW/Archipelago.MultiClient.Java)      |                                                                                 |
+| .NET (C# / C++ / F# / VB.NET) | [Archipelago.MultiClient.Net](https://www.nuget.org/packages/Archipelago.MultiClient.Net)          |                                                                                 |
+| C++                           | [apclientpp](https://github.com/black-sliver/apclientpp)                                           | almost-header-only                                                              |
+|                               | [APCpp](https://github.com/N00byKing/APCpp)                                                        | CMake                                                                           |
+| JavaScript / TypeScript       | [archipelago.js](https://www.npmjs.com/package/archipelago.js)                                     | Browser and Node.js Supported                                                   |
+| Haxe                          | [hxArchipelago](https://lib.haxe.org/p/hxArchipelago)                                              |                                                                                 |
 
 ## Synchronizing Items
 When the client receives a [ReceivedItems](#ReceivedItems) packet, if the `index` argument does not match the next index that the client expects then it is expected that the client will re-sync items with the server. This can be accomplished by sending the server a [Sync](#Sync) packet and then a [LocationChecks](#LocationChecks) packet.
@@ -152,7 +161,8 @@ The arguments for RoomUpdate are identical to [RoomInfo](#RoomInfo) barring:
 All arguments for this packet are optional, only changes are sent.
 
 ### Print
-Sent to clients purely to display a message to the player.
+Sent to clients purely to display a message to the player. 
+* *Deprecation warning: clients that connect with version 0.3.5 or higher will nolonger recieve Print packets, instead all messsages are send as [PrintJSON](#PrintJSON)*
 #### Arguments
 | Name | Type | Notes |
 | ---- | ---- | ----- |
@@ -164,10 +174,21 @@ Sent to clients purely to display a message to the player. This packet differs f
 | Name | Type | Notes |
 | ---- | ---- | ----- |
 | data | list\[[JSONMessagePart](#JSONMessagePart)\] | Type of this part of the message. |
-| type | str | May be present to indicate the nature of this message. Known types are Hint and ItemSend. |
+| type | str | May be present to indicate the [PrintJsonType](#PrintJsonType) of this message. |
 | receiving | int | Is present if type is Hint or ItemSend and marks the destination player's ID. |
 | item | [NetworkItem](#NetworkItem) | Is present if type is Hint or ItemSend and marks the source player id, location id, item id and item flags. |
 | found | bool | Is present if type is Hint, denotes whether the location hinted for was checked. |
+| countdown | int | Is present if type is `Countdown`, denotes the amount of seconds remaining on the countdown. |
+
+##### PrintJsonType
+PrintJsonType indicates the type of [PrintJson](#PrintJson) packet, different types can be handled differently by the client and can also contain additional arguments. When receiving an unknown type the data's list\[[JSONMessagePart](#JSONMessagePart)\] should still be printed as normal. 
+
+Currently defined types are:
+| Type | Notes |
+| ---- | ----- |
+| ItemSend | The message is in response to a player receiving an item. |
+| Hint | The message is in response to a player hinting. |
+| Countdown | The message contains information about the current server Countdown. |
 
 ### DataPackage
 Sent to clients to provide what is known as a 'data package' which contains information to enable a client to most easily communicate with the Archipelago server. Contents include things like location id to name mappings, among others; see [Data Package Contents](#Data-Package-Contents) for more info.

docs/running from source.md

@@ -56,3 +56,8 @@ SNI is required to use SNIClient. If not integrated into the project, it has to
 You can get the latest SNI release at [SNI Github releases](https://github.com/alttpo/sni/releases).
 It should be dropped as "SNI" into the root folder of the project. Alternatively, you can point the sni setting in
 host.yaml at your SNI folder.
+
+
+## Running tests
+
+Run `pip install pytest pytest-subtests`, then use your IDE to run tests or run `pytest` from the source folder.

docs/world api.md

@@ -103,8 +103,9 @@ or boss drops for RPG-like games but could also be progress in a research tree.
 
 Each location has a `name` and an `id` (a.k.a. "code" or "address"), is placed
 in a Region and has access rules.
-The name needs to be unique in each game, the ID needs to be unique across all
-games and is best in the same range as the item IDs.
+The name needs to be unique in each game and must not be numeric (has to
+contain least 1 letter or symbol). The ID needs to be unique across all games
+and is best in the same range as the item IDs.
 World-specific IDs are 1 to 2<sup>53</sup>-1, IDs ≤ 0 are global and reserved.
 
 Special locations with ID `None` can hold events.
@@ -121,6 +122,9 @@ their world. Progression items will be assigned to locations with higher
 priority and moved around to meet defined rules and accomplish progression
 balancing.
 
+The name needs to be unique in each game, meaning a duplicate item has the
+same ID. Name must not be numeric (has to contain at least 1 letter or symbol).
+
 Special items with ID `None` can mark events (read below).
 
 Other classifications include
@@ -188,15 +192,17 @@ the `/worlds` directory. The starting point for the package is `__init.py__`.
 Conventionally, your world class is placed in that file.
 
 World classes must inherit from the `World` class in `/worlds/AutoWorld.py`,
-which can be imported as `..AutoWorld.World` from your package.
+which can be imported as `worlds.AutoWorld.World` from your package.
 
 AP will pick up your world automatically due to the `AutoWorld` implementation.
 
 ### Requirements
 
 If your world needs specific python packages, they can be listed in
-`world/[world_name]/requirements.txt`.
-See [pip documentation](https://pip.pypa.io/en/stable/cli/pip_install/#requirements-file-format)
+`world/[world_name]/requirements.txt`. ModuleUpdate.py will automatically
+pick up and install them.
+
+See [pip documentation](https://pip.pypa.io/en/stable/cli/pip_install/#requirements-file-format).
 
 ### Relative Imports
 
@@ -209,6 +215,10 @@ e.g. `from .Options import mygame_options` from your `__init__.py` will load
 When imported names pile up it may be easier to use `from . import Options`
 and access the variable as `Options.mygame_options`.
 
+Imports from directories outside your world should use absolute imports.
+Correct use of relative / absolute imports is required for zipped worlds to
+function, see [apworld specification.md](apworld%20specification.md).
+
 ### Your Item Type
 
 Each world uses its own subclass of `BaseClasses.Item`. The constuctor can be
@@ -274,14 +284,12 @@ Define a property `option_<name> = <number>` per selectable value and
 `default = <number>` to set the default selection. Aliases can be set by
 defining a property `alias_<name> = <same number>`.
 
-One special case where aliases are required is when option name is `yes`, `no`,
-`on` or `off` because they parse to `True` or `False`:
 ```python
 option_off = 0
 option_on = 1
 option_some = 2
-alias_false = 0
-alias_true = 1
+alias_disabled = 0
+alias_enabled = 1
 default = 0
 ```
 
@@ -323,7 +331,7 @@ mygame_options: typing.Dict[str, type(Option)] = {
 ```python
 # __init__.py
 
-from ..AutoWorld import World
+from worlds.AutoWorld import World
 from .Options import mygame_options  # import the options dict
 
 class MyGameWorld(World):
@@ -352,7 +360,7 @@ more natural. These games typically have been edited to 'bake in' the items.
 from .Options import mygame_options  # the options we defined earlier
 from .Items import mygame_items  # data used below to add items to the World
 from .Locations import mygame_locations  # same as above
-from ..AutoWorld import World
+from worlds.AutoWorld import World
 from BaseClasses import Region, Location, Entrance, Item, RegionType, ItemClassification
 from Utils import get_options, output_path
 
@@ -553,7 +561,7 @@ def generate_basic(self) -> None:
 ### Setting Rules
 
 ```python
-from ..generic.Rules import add_rule, set_rule, forbid_item
+from worlds.generic.Rules import add_rule, set_rule, forbid_item
 from Items import get_item_type
 
 def set_rules(self) -> None:
@@ -603,7 +611,7 @@ implement more complex logic in logic mixins, even if there is no need to add
 properties to the `BaseClasses.CollectionState` state object.
 
 When importing a file that defines a class that inherits from
-`..AutoWorld.LogicMixin` the state object's class is automatically extended by
+`worlds.AutoWorld.LogicMixin` the state object's class is automatically extended by
 the mixin's members. These members should be prefixed with underscore following
 the name of the implementing world. This is due to sharing a namespace with all
 other logic mixins.
@@ -622,7 +630,7 @@ Please do this with caution and only when neccessary.
 ```python
 # Logic.py
 
-from ..AutoWorld import LogicMixin
+from worlds.AutoWorld import LogicMixin
 
 class MyGameLogic(LogicMixin):
     def _mygame_has_key(self, world: MultiWorld, player: int):
@@ -633,7 +641,7 @@ class MyGameLogic(LogicMixin):
 ```python
 # __init__.py
 
-from ..generic.Rules import set_rule
+from worlds.generic.Rules import set_rule
 import .Logic  # apply the mixin by importing its file
 
 class MyGameWorld(World):

inno_setup.iss

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

requirements.txt

@@ -3,6 +3,6 @@ websockets>=10.3
 PyYAML>=6.0
 jellyfish>=0.9.0
 jinja2>=3.1.2
-schema>=0.7.4
+schema>=0.7.5
 kivy>=2.1.0
 bsdiff4>=1.2.2

test/general/TestFill.py

@@ -371,13 +371,13 @@ class TestDistributeItemsRestrictive(unittest.TestCase):
 
         distribute_items_restrictive(multi_world)
 
-        self.assertEqual(locations[0].item, basic_items[0])
+        self.assertEqual(locations[0].item, basic_items[1])
         self.assertFalse(locations[0].event)
         self.assertEqual(locations[1].item, prog_items[0])
         self.assertTrue(locations[1].event)
         self.assertEqual(locations[2].item, prog_items[1])
         self.assertTrue(locations[2].event)
-        self.assertEqual(locations[3].item, basic_items[1])
+        self.assertEqual(locations[3].item, basic_items[0])
         self.assertFalse(locations[3].event)
 
     def test_excluded_distribute(self):
@@ -500,8 +500,8 @@ class TestDistributeItemsRestrictive(unittest.TestCase):
         removed_item: list[Item] = []
         removed_location: list[Location] = []
 
-        def fill_hook(progitempool, nonexcludeditempool, localrestitempool, nonlocalrestitempool, restitempool, fill_locations):
-            removed_item.append(restitempool.pop(0))
+        def fill_hook(progitempool, usefulitempool, filleritempool, fill_locations):
+            removed_item.append(filleritempool.pop(0))
             removed_location.append(fill_locations.pop(0))
 
         multi_world.worlds[player1.id].fill_hook = fill_hook

test/general/TestIDs.py

@@ -52,3 +52,13 @@ class TestIDs(unittest.TestCase):
                 else:
                     for location_id in world_type.location_id_to_name:
                         self.assertGreater(location_id, 0)
+
+    def testDuplicateItemIDs(self):
+        for gamename, world_type in AutoWorldRegister.world_types.items():
+            with self.subTest(game=gamename):
+                self.assertEqual(len(world_type.item_id_to_name), len(world_type.item_name_to_id))
+
+    def testDuplicateLocationIDs(self):
+        for gamename, world_type in AutoWorldRegister.world_types.items():
+            with self.subTest(game=gamename):
+                self.assertEqual(len(world_type.location_id_to_name), len(world_type.location_name_to_id))

test/general/TestItems.py

@@ -1,5 +1,6 @@
 import unittest
 from worlds.AutoWorld import AutoWorldRegister
+from . import setup_default_world
 
 
 class TestBase(unittest.TestCase):
@@ -29,3 +30,17 @@ class TestBase(unittest.TestCase):
                         with self.subTest(group_name, group_name=group_name):
                             for item in items:
                                 self.assertIn(item, world_type.item_name_to_id)
+
+    def testItemCountGreaterEqualLocations(self):
+        for game_name, world_type in AutoWorldRegister.world_types.items():
+
+            if game_name in {"Final Fantasy"}:
+                continue
+            with self.subTest("Game", game=game_name):
+                world = setup_default_world(world_type)
+                location_count = sum(0 if location.event or location.item else 1 for location in world.get_locations())
+                self.assertGreaterEqual(
+                    len(world.itempool),
+                    location_count,
+                    f"{game_name} Item count MUST meet or exceede the number of locations",
+                )

test/general/TestNames.py

@@ -0,0 +1,20 @@
+import unittest
+from worlds.AutoWorld import AutoWorldRegister
+
+
+class TestNames(unittest.TestCase):
+    def testItemNamesFormat(self):
+        """Item names must not be all numeric in order to differentiate between ID and name in !hint"""
+        for gamename, world_type in AutoWorldRegister.world_types.items():
+            with self.subTest(game=gamename):
+                for item_name in world_type.item_name_to_id:
+                    self.assertFalse(item_name.isnumeric(),
+                                     f"Item name \"{item_name}\" is invalid. It must not be numeric.")
+
+    def testLocationNameFormat(self):
+        """Location names must not be all numeric in order to differentiate between ID and name in !hint_location"""
+        for gamename, world_type in AutoWorldRegister.world_types.items():
+            with self.subTest(game=gamename):
+                for location_name in world_type.location_name_to_id:
+                    self.assertFalse(location_name.isnumeric(),
+                                     f"Location name \"{location_name}\" is invalid. It must not be numeric.")

test/webhost/TestFileGeneration.py

@@ -0,0 +1,34 @@
+"""Tests for successful generation of WebHost cached files. Can catch some other deeper errors."""
+
+import os
+import unittest
+
+import WebHost
+
+
+class TestFileGeneration(unittest.TestCase):
+    def setUp(self) -> None:
+        self.correct_path = os.path.join(os.path.dirname(WebHost.__file__), "WebHostLib")
+        # should not create the folder *here*
+        self.incorrect_path = os.path.join(os.path.split(os.path.dirname(__file__))[0], "WebHostLib")
+
+    def testOptions(self):
+        WebHost.create_options_files()
+        target = os.path.join(self.correct_path, "static", "generated", "configs")
+        self.assertTrue(os.path.exists(target))
+        self.assertFalse(os.path.exists(os.path.join(self.incorrect_path, "static", "generated", "configs")))
+
+        # folder seems fine, so now we try to generate Options based on the default file
+        from WebHostLib.check import roll_options
+        file: os.DirEntry
+        for file in os.scandir(target):
+            if file.is_file() and file.name.endswith(".yaml"):
+                with self.subTest(file=file.name):
+                    with open(file) as f:
+                        for value in roll_options({file.name: f.read()})[0].values():
+                            self.assertTrue(value is True, f"Default Options for template {file.name} cannot be run.")
+
+    def testTutorial(self):
+        WebHost.create_ordered_tutorials_file()
+        self.assertTrue(os.path.exists(os.path.join(self.correct_path, "static", "generated", "tutorials.json")))
+        self.assertFalse(os.path.exists(os.path.join(self.incorrect_path, "static", "generated", "tutorials.json")))

worlds/AutoWorld.py

@@ -27,7 +27,8 @@ class AutoWorldRegister(type):
 
         # build rest
         dct["item_names"] = frozenset(dct["item_name_to_id"])
-        dct["item_name_groups"] = dct.get("item_name_groups", {})
+        dct["item_name_groups"] = {group_name: frozenset(group_set) for group_name, group_set
+                                   in dct.get("item_name_groups", {}).items()}
         dct["item_name_groups"]["Everything"] = dct["item_names"]
         dct["location_names"] = frozenset(dct["location_name_to_id"])
         dct["all_item_and_group_names"] = frozenset(dct["item_names"] | set(dct.get("item_name_groups", {})))
@@ -97,22 +98,22 @@ def call_stage(world: "MultiWorld", method_name: str, *args: Any) -> None:
 
 class WebWorld:
     """Webhost integration"""
-    # display a settings page. Can be a link to an out-of-ap settings tool too.
+    
     settings_page: Union[bool, str] = True
-
-    # docs folder will be scanned for game info pages using this list in the format '{language}_{game_name}.md'
+    """display a settings page. Can be a link to a specific page or external tool."""
+    
     game_info_languages: List[str] = ['en']
+    """docs folder will be scanned for game info pages using this list in the format '{language}_{game_name}.md'"""
 
-    # docs folder will also be scanned for tutorial guides given the relevant information in this list. Each Tutorial
-    # class is to be used for one guide.
     tutorials: List["Tutorial"]
+    """docs folder will also be scanned for tutorial guides. Each Tutorial class is to be used for one guide."""
 
-    # Choose a theme for your /game/* pages
-    # Available: dirt, grass, grassFlowers, ice, jungle, ocean, partyTime, stone
     theme = "grass"
+    """Choose a theme for you /game/* pages.
+    Available: dirt, grass, grassFlowers, ice, jungle, ocean, partyTime, stone"""
 
-    # display a link to a bug report page, most likely a link to a GitHub issue page.
     bug_report_page: Optional[str]
+    """display a link to a bug report page, most likely a link to a GitHub issue page."""
 
 
 class World(metaclass=AutoWorldRegister):
@@ -220,10 +221,8 @@ class World(metaclass=AutoWorldRegister):
     @classmethod
     def fill_hook(cls,
                   progitempool: List["Item"],
-                  nonexcludeditempool: List["Item"],
-                  localrestitempool: Dict[int, List["Item"]],
-                  nonlocalrestitempool: Dict[int, List["Item"]],
-                  restitempool: List["Item"],
+                  usefulitempool: List["Item"],
+                  filleritempool: List["Item"],
                   fill_locations: List["Location"]) -> None:
         """Special method that gets called as part of distribute_items_restrictive (main fill).
         This gets called once per present world type."""
@@ -241,6 +240,11 @@ class World(metaclass=AutoWorldRegister):
         """Fill in the slot_data field in the Connected network package."""
         return {}
 
+    def extend_hint_information(self, hint_data: Dict[int, Dict[int, str]]):
+        """Fill in additional entrance information text into locations, which is displayed when hinted.
+        structure is {player_id: {location_id: text}} You will need to insert your own player_id."""
+        pass
+
     def modify_multidata(self, multidata: Dict[str, Any]) -> None:  # TODO: TypedDict for multidata?
         """For deeper modification of server multidata."""
         pass

worlds/__init__.py

@@ -27,7 +27,8 @@ class WorldSource(typing.NamedTuple):
 world_sources: typing.List[WorldSource] = []
 file: os.DirEntry  # for me (Berserker) at least, PyCharm doesn't seem to infer the type correctly
 for file in os.scandir(folder):
-    if not file.name.startswith("_"):  # prevent explicitly loading __pycache__ and allow _* names for non-world folders
+    # prevent loading of __pycache__ and allow _* for non-world folders, disable files/folders starting with "."
+    if not file.name.startswith(("_", ".")):
         if file.is_dir():
             world_sources.append(WorldSource(file.name))
         elif file.is_file() and file.name.endswith(".apworld"):

worlds/alttp/Bosses.py

@@ -1,8 +1,9 @@
 import logging
-from typing import Optional
+from typing import Optional, Union, List, Tuple, Callable, Dict
 
 from BaseClasses import Boss
 from Fill import FillError
+from .Options import Bosses
 
 
 def BossFactory(boss: str, player: int) -> Optional[Boss]:
@@ -12,7 +13,7 @@ def BossFactory(boss: str, player: int) -> Optional[Boss]:
     raise Exception('Unknown Boss: %s', boss)
 
 
-def ArmosKnightsDefeatRule(state, player: int):
+def ArmosKnightsDefeatRule(state, player: int) -> bool:
     # Magic amounts are probably a bit overkill
     return (
             state.has_melee_weapon(player) or
@@ -25,7 +26,7 @@ def ArmosKnightsDefeatRule(state, player: int):
             state.has('Red Boomerang', player))
 
 
-def LanmolasDefeatRule(state, player: int):
+def LanmolasDefeatRule(state, player: int) -> bool:
     return (
             state.has_melee_weapon(player) or
             state.has('Fire Rod', player) or
@@ -35,16 +36,16 @@ def LanmolasDefeatRule(state, player: int):
             state.can_shoot_arrows(player))
 
 
-def MoldormDefeatRule(state, player: int):
+def MoldormDefeatRule(state, player: int) -> bool:
     return state.has_melee_weapon(player)
 
 
-def HelmasaurKingDefeatRule(state, player: int):
+def HelmasaurKingDefeatRule(state, player: int) -> bool:
     # TODO: technically possible with the hammer
     return state.has_sword(player) or state.can_shoot_arrows(player)
 
 
-def ArrghusDefeatRule(state, player: int):
+def ArrghusDefeatRule(state, player: int) -> bool:
     if not state.has('Hookshot', player):
         return False
     # TODO: ideally we would have a check for bow and silvers, which combined with the
@@ -58,7 +59,7 @@ def ArrghusDefeatRule(state, player: int):
             (state.has('Ice Rod', player) and (state.can_shoot_arrows(player) or state.can_extend_magic(player, 16))))
 
 
-def MothulaDefeatRule(state, player: int):
+def MothulaDefeatRule(state, player: int) -> bool:
     return (
             state.has_melee_weapon(player) or
             (state.has('Fire Rod', player) and state.can_extend_magic(player, 10)) or
@@ -70,11 +71,11 @@ def MothulaDefeatRule(state, player: int):
     )
 
 
-def BlindDefeatRule(state, player: int):
+def BlindDefeatRule(state, player: int) -> bool:
     return state.has_melee_weapon(player) or state.has('Cane of Somaria', player) or state.has('Cane of Byrna', player)
 
 
-def KholdstareDefeatRule(state, player: int):
+def KholdstareDefeatRule(state, player: int) -> bool:
     return (
             (
                     state.has('Fire Rod', player) or
@@ -96,11 +97,11 @@ def KholdstareDefeatRule(state, player: int):
     )
 
 
-def VitreousDefeatRule(state, player: int):
+def VitreousDefeatRule(state, player: int) -> bool:
     return state.can_shoot_arrows(player) or state.has_melee_weapon(player)
 
 
-def TrinexxDefeatRule(state, player: int):
+def TrinexxDefeatRule(state, player: int) -> bool:
     if not (state.has('Fire Rod', player) and state.has('Ice Rod', player)):
         return False
     return state.has('Hammer', player) or state.has('Tempered Sword', player) or state.has('Golden Sword', player) or \
@@ -108,11 +109,11 @@ def TrinexxDefeatRule(state, player: int):
            (state.has_sword(player) and state.can_extend_magic(player, 32))
 
 
-def AgahnimDefeatRule(state, player: int):
+def AgahnimDefeatRule(state, player: int) -> bool:
     return state.has_sword(player) or state.has('Hammer', player) or state.has('Bug Catching Net', player)
 
 
-def GanonDefeatRule(state, player: int):
+def GanonDefeatRule(state, player: int) -> bool:
     if state.world.swordless[player]:
         return state.has('Hammer', player) and \
                state.has_fire_source(player) and \
@@ -132,7 +133,7 @@ def GanonDefeatRule(state, player: int):
         return common and state.has('Silver Bow', player) and state.can_shoot_arrows(player)
 
 
-boss_table = {
+boss_table: Dict[str, Tuple[str, Optional[Callable]]] = {
     'Armos Knights': ('Armos', ArmosKnightsDefeatRule),
     'Lanmolas': ('Lanmola', LanmolasDefeatRule),
     'Moldorm': ('Moldorm', MoldormDefeatRule),
@@ -147,7 +148,7 @@ boss_table = {
     'Agahnim2': ('Agahnim2', AgahnimDefeatRule)
 }
 
-boss_location_table = [
+boss_location_table: List[Tuple[str, str]] = [
         ('Ganons Tower', 'top'),
         ('Tower of Hera', None),
         ('Skull Woods', None),
@@ -164,6 +165,34 @@ boss_location_table = [
     ]
 
 
+def place_plando_bosses(bosses: List[str], world, player: int) -> Tuple[List[str], List[Tuple[str, str]]]:
+    # Most to least restrictive order
+    boss_locations = boss_location_table.copy()
+    world.random.shuffle(boss_locations)
+    boss_locations.sort(key=lambda location: -int(restrictive_boss_locations[location]))
+    already_placed_bosses: List[str] = []
+
+    for boss in bosses:
+        if "-" in boss:  # handle plando locations
+            loc, boss = boss.split("-")
+            boss = boss.title()
+            level: str = None
+            if loc.split(" ")[-1] in {"top", "middle", "bottom"}:
+                # split off level
+                loc = loc.split(" ")
+                level = loc[-1]
+                loc = " ".join(loc[:-1])
+            loc = loc.title().replace("Of", "of")
+            place_boss(world, player, boss, loc, level)
+            already_placed_bosses.append(boss)
+            boss_locations.remove((loc, level))
+        else:  # boss chosen with no specified locations
+            boss = boss.title()
+            boss_locations, already_placed_bosses = place_where_possible(world, player, boss, boss_locations)
+
+    return already_placed_bosses, boss_locations
+
+
 def can_place_boss(boss: str, dungeon_name: str, level: Optional[str] = None) -> bool:
     # blacklist approach
     if boss in {"Agahnim", "Agahnim2", "Ganon"}:
@@ -187,62 +216,50 @@ def can_place_boss(boss: str, dungeon_name: str, level: Optional[str] = None) ->
 
     return True
 
-restrictive_boss_locations = {}
+
+restrictive_boss_locations: Dict[Tuple[str, str], bool] = {}
 for location in boss_location_table:
     restrictive_boss_locations[location] = not all(can_place_boss(boss, *location)
                                                for boss in boss_table if not boss.startswith("Agahnim"))
 
-def place_boss(world, player: int, boss: str, location: str, level: Optional[str]):
+
+def place_boss(world, player: int, boss: str, location: str, level: Optional[str]) -> None:
     if location == 'Ganons Tower' and world.mode[player] == 'inverted':
         location = 'Inverted Ganons Tower'
     logging.debug('Placing boss %s at %s', boss, location + (' (' + level + ')' if level else ''))
     world.get_dungeon(location, player).bosses[level] = BossFactory(boss, player)
 
-def format_boss_location(location, level):
+
+def format_boss_location(location: str, level: str) -> str:
     return location + (' (' + level + ')' if level else '')
 
-def place_bosses(world, player: int):
-    if world.boss_shuffle[player] == 'none':
+
+def place_bosses(world, player: int) -> None:
+    # will either be an int or a lower case string with ';' between options
+    boss_shuffle: Union[str, int] = world.boss_shuffle[player].value
+    already_placed_bosses: List[str] = []
+    remaining_locations: List[Tuple[str, str]] = []
+    # handle plando
+    if isinstance(boss_shuffle, str):
+        # figure out our remaining mode, convert it to an int and remove it from plando_args
+        options = boss_shuffle.split(";")
+        boss_shuffle = Bosses.options[options.pop()]
+        # place our plando bosses
+        already_placed_bosses, remaining_locations = place_plando_bosses(options, world, player)
+    if boss_shuffle == Bosses.option_none:  # vanilla boss locations
         return
+
     # Most to least restrictive order
-    boss_locations = boss_location_table.copy()
-    world.random.shuffle(boss_locations)
-    boss_locations.sort(key= lambda location: -int(restrictive_boss_locations[location]))
+    if not remaining_locations and not already_placed_bosses:
+        remaining_locations = boss_location_table.copy()
+    world.random.shuffle(remaining_locations)
+    remaining_locations.sort(key=lambda location: -int(restrictive_boss_locations[location]))
 
     all_bosses = sorted(boss_table.keys())  # sorted to be deterministic on older pythons
     placeable_bosses = [boss for boss in all_bosses if boss not in ['Agahnim', 'Agahnim2', 'Ganon']]
 
-    shuffle_mode = world.boss_shuffle[player]
-    already_placed_bosses = []
-    if ";" in shuffle_mode:
-        bosses = shuffle_mode.split(";")
-        shuffle_mode = bosses.pop()
-        for boss in bosses:
-            if "-" in boss:
-                loc, boss = boss.split("-")
-                boss = boss.title()
-                level = None
-                if loc.split(" ")[-1] in {"top", "middle", "bottom"}:
-                    # split off level
-                    loc = loc.split(" ")
-                    level = loc[-1]
-                    loc = " ".join(loc[:-1])
-                loc = loc.title().replace("Of", "of")
-                if can_place_boss(boss, loc, level) and (loc, level) in boss_locations:
-                    place_boss(world, player, boss, loc, level)
-                    already_placed_bosses.append(boss)
-                    boss_locations.remove((loc, level))
-                else:
-                    raise Exception(f"Cannot place {boss} at {format_boss_location(loc, level)} for player {player}.")
-            else:
-                boss = boss.title()
-                boss_locations, already_placed_bosses = place_where_possible(world, player, boss, boss_locations)
-
-    if shuffle_mode == "none":
-        return  # vanilla bosses come pre-placed
-
-    if shuffle_mode in ["basic", "full"]:
-        if world.boss_shuffle[player] == "basic":  # vanilla bosses shuffled
+    if boss_shuffle == Bosses.option_basic or boss_shuffle == Bosses.option_full:
+        if boss_shuffle == Bosses.option_basic:  # vanilla bosses shuffled
             bosses = placeable_bosses + ['Armos Knights', 'Lanmolas', 'Moldorm']
         else:  # all bosses present, the three duplicates chosen at random
             bosses = placeable_bosses + world.random.sample(placeable_bosses, 3)
@@ -258,7 +275,7 @@ def place_bosses(world, player: int):
         logging.debug('Bosses chosen %s', bosses)
 
         world.random.shuffle(bosses)
-        for loc, level in boss_locations:
+        for loc, level in remaining_locations:
             for _ in range(len(bosses)):
                 boss = bosses.pop()
                 if can_place_boss(boss, loc, level):
@@ -272,8 +289,8 @@ def place_bosses(world, player: int):
 
             place_boss(world, player, boss, loc, level)
 
-    elif shuffle_mode == "chaos":  # all bosses chosen at random
-        for loc, level in boss_locations:
+    elif boss_shuffle == Bosses.option_chaos:  # all bosses chosen at random
+        for loc, level in remaining_locations:
             try:
                 boss = world.random.choice(
                     [b for b in placeable_bosses if can_place_boss(b, loc, level)])
@@ -282,9 +299,9 @@ def place_bosses(world, player: int):
             else:
                 place_boss(world, player, boss, loc, level)
 
-    elif shuffle_mode == "singularity":
+    elif boss_shuffle == Bosses.option_singularity:
         primary_boss = world.random.choice(placeable_bosses)
-        remaining_boss_locations, _ = place_where_possible(world, player, primary_boss, boss_locations)
+        remaining_boss_locations, _ = place_where_possible(world, player, primary_boss, remaining_locations)
         if remaining_boss_locations:
             # pick a boss to go into the remaining locations
             remaining_boss = world.random.choice([boss for boss in placeable_bosses if all(
@@ -293,12 +310,12 @@ def place_bosses(world, player: int):
             if remaining_boss_locations:
                 raise Exception("Unfilled boss locations!")
     else:
-        raise FillError(f"Could not find boss shuffle mode {shuffle_mode}")
+        raise FillError(f"Could not find boss shuffle mode {boss_shuffle}")
 
 
-def place_where_possible(world, player: int, boss: str, boss_locations):
-    remainder = []
-    placed_bosses = []
+def place_where_possible(world, player: int, boss: str, boss_locations) -> Tuple[List[Tuple[str, str]], List[str]]:
+    remainder: List[Tuple[str, str]] = []
+    placed_bosses: List[str] = []
     for loc, level in boss_locations:
         # place that boss where it can go
         if can_place_boss(boss, loc, level):

worlds/alttp/EntranceRandomizer.py

@@ -212,9 +212,7 @@ def parse_arguments(argv, no_defaults=False):
                              Alternatively, can be a ALttP Rom patched with a Link
                              sprite that will be extracted.
                              ''')
-    parser.add_argument('--gui', help='Launch the GUI', action='store_true')
 
-    parser.add_argument('--enemizercli', default=defval('EnemizerCLI/EnemizerCLI.Core'))
     parser.add_argument('--shufflebosses', default=defval('none'), choices=['none', 'basic', 'normal', 'chaos',
                                                                             "singularity"])
 

worlds/alttp/ItemPool.py

@@ -480,7 +480,7 @@ def set_up_take_anys(world, player):
     old_man_take_any.shop = TakeAny(old_man_take_any, 0x0112, 0xE2, True, True, total_shop_slots)
     world.shops.append(old_man_take_any.shop)
 
-    swords = [item for item in world.itempool if item.type == 'Sword' and item.player == player]
+    swords = [item for item in world.itempool if item.player == player and item.type == 'Sword']
     if swords:
         sword = world.random.choice(swords)
         world.itempool.remove(sword)

worlds/alttp/Options.py

@@ -1,7 +1,7 @@
 import typing
 
 from BaseClasses import MultiWorld
-from Options import Choice, Range, Option, Toggle, DefaultOnToggle, DeathLink
+from Options import Choice, Range, Option, Toggle, DefaultOnToggle, DeathLink, TextChoice
 
 
 class Logic(Choice):
@@ -39,8 +39,6 @@ class OpenPyramid(Choice):
     option_auto = 3
     default = option_goal
 
-    alias_true = option_open
-    alias_false = option_closed
     alias_yes = option_open
     alias_no = option_closed
 
@@ -140,13 +138,143 @@ class WorldState(Choice):
     option_inverted = 2
 
 
-class Bosses(Choice):
-    option_vanilla = 0
-    option_simple = 1
+class Bosses(TextChoice):
+    """Shuffles bosses around to different locations.
+    Basic will shuffle all bosses except Ganon and Agahnim anywhere they can be placed.
+    Full chooses 3 bosses at random to be placed twice instead of Lanmolas, Moldorm, and Helmasaur.
+    Chaos allows any boss to appear any number of times.
+    Singularity places a single boss in as many places as possible, and a second boss in any remaining locations.
+    Supports plando placement. Formatting here: https://archipelago.gg/tutorial/A%20Link%20to%20the%20Past/plando/en"""
+    display_name = "Boss Shuffle"
+    option_none = 0
+    option_basic = 1
     option_full = 2
     option_chaos = 3
     option_singularity = 4
 
+    bosses: set = {
+        "Armos Knights",
+        "Lanmolas",
+        "Moldorm",
+        "Helmasaur King",
+        "Arrghus",
+        "Mothula",
+        "Blind",
+        "Kholdstare",
+        "Vitreous",
+        "Trinexx",
+    }
+
+    locations: set = {
+        "Ganons Tower Top",
+        "Tower of Hera",
+        "Skull Woods",
+        "Ganons Tower Middle",
+        "Eastern Palace",
+        "Desert Palace",
+        "Palace of Darkness",
+        "Swamp Palace",
+        "Thieves Town",
+        "Ice Palace",
+        "Misery Mire",
+        "Turtle Rock",
+        "Ganons Tower Bottom"
+    }
+
+    def __init__(self, value: typing.Union[str, int]):
+        assert isinstance(value, str) or isinstance(value, int), \
+            f"{value} is not a valid option for {self.__class__.__name__}"
+        self.value = value
+
+    @classmethod
+    def from_text(cls, text: str):
+        import random
+        # set all of our text to lower case for name checking
+        text = text.lower()
+        cls.bosses = {boss_name.lower() for boss_name in cls.bosses}
+        cls.locations = {boss_location.lower() for boss_location in cls.locations}
+        if text == "random":
+            return cls(random.choice(list(cls.options.values())))
+        for option_name, value in cls.options.items():
+            if option_name == text:
+                return cls(value)
+        options = text.split(";")
+
+        # since plando exists in the option verify the plando values given are valid
+        cls.validate_plando_bosses(options)
+
+        # find out what type of boss shuffle we should use for placing bosses after plando
+        # and add as a string to look nice in the spoiler
+        if "random" in options:
+            shuffle = random.choice(list(cls.options))
+            options.remove("random")
+            options = ";".join(options) + ";" + shuffle
+            boss_class = cls(options)
+        else:
+            for option in options:
+                if option in cls.options:
+                    boss_class = cls(";".join(options))
+                    break
+            else:
+                if len(options) == 1:
+                    if cls.valid_boss_name(options[0]):
+                        options = options[0] + ";singularity"
+                        boss_class = cls(options)
+                    else:
+                        options = options[0] + ";none"
+                        boss_class = cls(options)
+                else:
+                    options = ";".join(options) + ";none"
+                    boss_class = cls(options)
+        return boss_class
+
+    @classmethod
+    def validate_plando_bosses(cls, options: typing.List[str]) -> None:
+        from .Bosses import can_place_boss, format_boss_location
+        for option in options:
+            if option == "random" or option in cls.options:
+                if option != options[-1]:
+                    raise ValueError(f"{option} option must be at the end of the boss_shuffle options!")
+                continue
+            if "-" in option:
+                location, boss = option.split("-")
+                level = ''
+                if not cls.valid_boss_name(boss):
+                    raise ValueError(f"{boss} is not a valid boss name for location {location}.")
+                if not cls.valid_location_name(location):
+                    raise ValueError(f"{location} is not a valid boss location name.")
+                if location.split(" ")[-1] in ("top", "middle", "bottom"):
+                    location = location.split(" ")
+                    level = location[-1]
+                    location = " ".join(location[:-1])
+                location = location.title().replace("Of", "of")
+                if not can_place_boss(boss.title(), location, level):
+                    raise ValueError(f"{format_boss_location(location, level)} "
+                                     f"is not a valid location for {boss.title()}.")
+            else:
+                if not cls.valid_boss_name(option):
+                    raise ValueError(f"{option} is not a valid boss name.")
+
+    @classmethod
+    def valid_boss_name(cls, value: str) -> bool:
+        return value.lower() in cls.bosses
+
+    @classmethod
+    def valid_location_name(cls, value: str) -> bool:
+        return value in cls.locations
+
+    def verify(self, world, player_name: str, plando_options) -> None:
+        if isinstance(self.value, int):
+            return
+        from Generate import PlandoSettings
+        if not(PlandoSettings.bosses & plando_options):
+            import logging
+            # plando is disabled but plando options were given so pull the option and change it to an int
+            option = self.value.split(";")[-1]
+            self.value = self.options[option]
+            logging.warning(f"The plando bosses module is turned off, so {self.name_lookup[self.value].title()} "
+                    f"boss shuffle will be used for player {player_name}.")
+
 
 class Enemies(Choice):
     option_vanilla = 0
@@ -159,8 +287,6 @@ class Progressive(Choice):
     option_off = 0
     option_grouped_random = 1
     option_on = 2
-    alias_false = 0
-    alias_true = 2
     default = 2
 
     def want_progressives(self, random):
@@ -168,8 +294,8 @@ class Progressive(Choice):
 
 
 class Swordless(Toggle):
-    """No swords. Curtains in Skull Woods and Agahnim\'s
-    Tower are removed, Agahnim\'s Tower barrier can be
+    """No swords. Curtains in Skull Woods and Agahnim's
+    Tower are removed, Agahnim's Tower barrier can be
     destroyed with hammer. Misery Mire and Turtle Rock
     can be opened without a sword. Hammer damages Ganon.
     Ether and Bombos Tablet can be activated with Hammer
@@ -202,8 +328,6 @@ class Hints(Choice):
     option_on = 2
     option_full = 3
     default = 2
-    alias_false = 0
-    alias_true = 2
 
 
 class Scams(Choice):
@@ -213,7 +337,6 @@ class Scams(Choice):
     option_king_zora = 1
     option_bottle_merchant = 2
     option_all = 3
-    alias_false = 0
 
     @property
     def gives_king_zora_hint(self):
@@ -282,8 +405,8 @@ class ShieldPalette(Palette):
     display_name = "Shield Palette"
 
 
-class LinkPalette(Palette):
-    display_name = "Link Palette"
+# class LinkPalette(Palette):
+#     display_name = "Link Palette"
 
 
 class HeartBeep(Choice):
@@ -293,7 +416,6 @@ class HeartBeep(Choice):
     option_half = 2
     option_quarter = 3
     option_off = 4
-    alias_false = 4
 
 
 class HeartColor(Choice):
@@ -375,6 +497,7 @@ alttp_options: typing.Dict[str, type(Option)] = {
     "hints": Hints,
     "scams": Scams,
     "restrict_dungeon_item_on_boss": RestrictBossItem,
+    "boss_shuffle": Bosses,
     "pot_shuffle": PotShuffle,
     "enemy_shuffle": EnemyShuffle,
     "killable_thieves": KillableThieves,
@@ -387,7 +510,7 @@ alttp_options: typing.Dict[str, type(Option)] = {
     "hud_palettes": HUDPalette,
     "sword_palettes": SwordPalette,
     "shield_palettes": ShieldPalette,
-    "link_palettes": LinkPalette,
+    # "link_palettes": LinkPalette,
     "heartbeep": HeartBeep,
     "heartcolor": HeartColor,
     "quickswap": QuickSwap,

worlds/alttp/Regions.py

@@ -4,6 +4,10 @@ import typing
 from BaseClasses import Region, Entrance, RegionType
 
 
+def is_main_entrance(entrance: Entrance) -> bool:
+    return entrance.parent_region.type in {RegionType.DarkWorld, RegionType.LightWorld, RegionType.Generic}
+
+
 def create_regions(world, player):
 
     world.regions += [

worlds/alttp/Rom.py

@@ -34,7 +34,7 @@ from worlds.alttp.Text import KingsReturn_texts, Sanctuary_texts, Kakariko_texts
     DeathMountain_texts, \
     LostWoods_texts, WishingWell_texts, DesertPalace_texts, MountainTower_texts, LinksHouse_texts, Lumberjacks_texts, \
     SickKid_texts, FluteBoy_texts, Zora_texts, MagicShop_texts, Sahasrahla_names
-from Utils import local_path, user_path, int16_as_bytes, int32_as_bytes, snes_to_pc, is_frozen
+from Utils import local_path, user_path, int16_as_bytes, int32_as_bytes, snes_to_pc, is_frozen, parse_yaml
 from worlds.alttp.Items import ItemFactory, item_table, item_name_groups, progression_items
 from worlds.alttp.EntranceShuffle import door_addresses
 from worlds.alttp.Options import smallkey_shuffle
@@ -551,18 +551,22 @@ class Sprite():
         Sprite.base_data = Sprite.sprite + Sprite.palette + Sprite.glove_palette
 
     def from_ap_sprite(self, filedata):
-        filedata = filedata.decode("utf-8-sig")
-        import yaml
-        obj = yaml.safe_load(filedata)
-        if obj["min_format_version"] > 1:
-            raise Exception("Sprite file requires an updated reader.")
-        self.author_name = obj["author"]
-        self.name = obj["name"]
-        if obj["data"]:  # skip patching for vanilla content
-            data = bsdiff4.patch(Sprite.base_data, obj["data"])
-            self.sprite = data[:self.sprite_size]
-            self.palette = data[self.sprite_size:self.palette_size]
-            self.glove_palette = data[self.sprite_size + self.palette_size:]
+        # noinspection PyBroadException
+        try:
+            obj = parse_yaml(filedata.decode("utf-8-sig"))
+            if obj["min_format_version"] > 1:
+                raise Exception("Sprite file requires an updated reader.")
+            self.author_name = obj["author"]
+            self.name = obj["name"]
+            if obj["data"]:  # skip patching for vanilla content
+                data = bsdiff4.patch(Sprite.base_data, obj["data"])
+                self.sprite = data[:self.sprite_size]
+                self.palette = data[self.sprite_size:self.palette_size]
+                self.glove_palette = data[self.sprite_size + self.palette_size:]
+        except Exception:
+            logger = logging.getLogger("apsprite")
+            logger.exception("Error parsing apsprite file")
+            self.valid = False
 
     @property
     def author_game_display(self) -> str:
@@ -659,7 +663,7 @@ class Sprite():
 
     @staticmethod
     def parse_zspr(filedata, expected_kind):
-        logger = logging.getLogger('ZSPR')
+        logger = logging.getLogger("ZSPR")
         headerstr = "<4xBHHIHIHH6x"
         headersize = struct.calcsize(headerstr)
         if len(filedata) < headersize:
@@ -667,7 +671,7 @@ class Sprite():
         version, csum, icsum, sprite_offset, sprite_size, palette_offset, palette_size, kind = struct.unpack_from(
             headerstr, filedata)
         if version not in [1]:
-            logger.error('Error parsing ZSPR file: Version %g not supported', version)
+            logger.error("Error parsing ZSPR file: Version %g not supported", version)
             return None
         if kind != expected_kind:
             return None
@@ -676,36 +680,42 @@ class Sprite():
         stream.seek(headersize)
 
         def read_utf16le(stream):
-            "Decodes a null-terminated UTF-16_LE string of unknown size from a stream"
+            """Decodes a null-terminated UTF-16_LE string of unknown size from a stream"""
             raw = bytearray()
             while True:
                 char = stream.read(2)
-                if char in [b'', b'\x00\x00']:
+                if char in [b"", b"\x00\x00"]:
                     break
                 raw += char
-            return raw.decode('utf-16_le')
+            return raw.decode("utf-16_le")
 
-        sprite_name = read_utf16le(stream)
-        author_name = read_utf16le(stream)
-        author_credits_name = stream.read().split(b"\x00", 1)[0].decode()
+        # noinspection PyBroadException
+        try:
+            sprite_name = read_utf16le(stream)
+            author_name = read_utf16le(stream)
+            author_credits_name = stream.read().split(b"\x00", 1)[0].decode()
 
-        # Ignoring the Author Rom name for the time being.
+            # Ignoring the Author Rom name for the time being.
 
-        real_csum = sum(filedata) % 0x10000
-        if real_csum != csum or real_csum ^ 0xFFFF != icsum:
-            logger.warning('ZSPR file has incorrect checksum. It may be corrupted.')
+            real_csum = sum(filedata) % 0x10000
+            if real_csum != csum or real_csum ^ 0xFFFF != icsum:
+                logger.warning("ZSPR file has incorrect checksum. It may be corrupted.")
 
-        sprite = filedata[sprite_offset:sprite_offset + sprite_size]
-        palette = filedata[palette_offset:palette_offset + palette_size]
+            sprite = filedata[sprite_offset:sprite_offset + sprite_size]
+            palette = filedata[palette_offset:palette_offset + palette_size]
 
-        if len(sprite) != sprite_size or len(palette) != palette_size:
-            logger.error('Error parsing ZSPR file: Unexpected end of file')
+            if len(sprite) != sprite_size or len(palette) != palette_size:
+                logger.error("Error parsing ZSPR file: Unexpected end of file")
+                return None
+
+            return sprite, palette, sprite_name, author_name, author_credits_name
+
+        except Exception:
+            logger.exception("Error parsing ZSPR file")
             return None
 
-        return (sprite, palette, sprite_name, author_name, author_credits_name)
-
     def decode_palette(self):
-        "Returns the palettes as an array of arrays of 15 colors"
+        """Returns the palettes as an array of arrays of 15 colors"""
 
         def array_chunk(arr, size):
             return list(zip(*[iter(arr)] * size))

worlds/alttp/__init__.py

@@ -4,6 +4,7 @@ import random
 import threading
 import typing
 
+import Utils
 from BaseClasses import Item, CollectionState, Tutorial
 from .Dungeons import create_dungeons
 from .EntranceShuffle import link_entrances, link_inverted_entrances, plando_connect
@@ -11,7 +12,8 @@ from .InvertedRegions import create_inverted_regions, mark_dark_world_regions
 from .ItemPool import generate_itempool, difficulties
 from .Items import item_init_table, item_name_groups, item_table, GetBeemizerItem
 from .Options import alttp_options, smallkey_shuffle
-from .Regions import lookup_name_to_id, create_regions, mark_light_world_regions
+from .Regions import lookup_name_to_id, create_regions, mark_light_world_regions, lookup_vanilla_location_to_entrance, \
+    is_main_entrance
 from .Rom import LocalRom, patch_rom, patch_race_rom, check_enemizer, patch_enemizer, apply_rom_settings, \
     get_hash_string, get_base_rom_path, LttPDeltaPatch
 from .Rules import set_rules
@@ -23,6 +25,7 @@ lttp_logger = logging.getLogger("A Link to the Past")
 
 extras_list = sum(difficulties['normal'].extras[0:5], [])
 
+
 class ALTTPWeb(WebWorld):
     setup_en = Tutorial(
         "Multiworld Setup Tutorial",
@@ -136,6 +139,10 @@ class ALTTPWorld(World):
 
     create_items = generate_itempool
 
+    enemizer_path: str = Utils.get_options()["generator"]["enemizer_path"] \
+        if os.path.isabs(Utils.get_options()["generator"]["enemizer_path"]) \
+        else Utils.local_path(Utils.get_options()["generator"]["enemizer_path"])
+
     def __init__(self, *args, **kwargs):
         self.dungeon_local_item_names = set()
         self.dungeon_specific_item_names = set()
@@ -150,12 +157,12 @@ class ALTTPWorld(World):
             raise FileNotFoundError(rom_file)
 
     def generate_early(self):
+        if self.use_enemizer():
+            check_enemizer(self.enemizer_path)
+
         player = self.player
         world = self.world
 
-        if self.use_enemizer():
-            check_enemizer(world.enemizer)
-
         # system for sharing ER layouts
         self.er_seed = str(world.random.randint(0, 2 ** 64))
 
@@ -344,7 +351,7 @@ class ALTTPWorld(World):
     def use_enemizer(self):
         world = self.world
         player = self.player
-        return (world.boss_shuffle[player] != 'none' or world.enemy_shuffle[player]
+        return (world.boss_shuffle[player] or world.enemy_shuffle[player]
                 or world.enemy_health[player] != 'default' or world.enemy_damage[player] != 'default'
                 or world.pot_shuffle[player] or world.bush_shuffle[player]
                 or world.killable_thieves[player])
@@ -360,7 +367,7 @@ class ALTTPWorld(World):
             patch_rom(world, rom, player, use_enemizer)
 
             if use_enemizer:
-                patch_enemizer(world, player, rom, world.enemizer, output_directory)
+                patch_enemizer(world, player, rom, self.enemizer_path, output_directory)
 
             if world.is_race:
                 patch_race_rom(rom, world, player)
@@ -373,7 +380,7 @@ class ALTTPWorld(World):
                 'hud': world.hud_palettes[player],
                 'sword': world.sword_palettes[player],
                 'shield': world.shield_palettes[player],
-                'link': world.link_palettes[player]
+                # 'link': world.link_palettes[player]
             }
             palettes_options = {key: option.current_key for key, option in palettes_options.items()}
 
@@ -405,6 +412,20 @@ class ALTTPWorld(World):
         finally:
             self.rom_name_available_event.set() # make sure threading continues and errors are collected
 
+    @classmethod
+    def stage_extend_hint_information(cls, world, hint_data: typing.Dict[int, typing.Dict[int, str]]):
+        er_hint_data = {player: {} for player in world.get_game_players("A Link to the Past") if
+                        world.shuffle[player] != "vanilla" or world.retro_caves[player]}
+
+        for region in world.regions:
+            if region.player in er_hint_data and region.locations:
+                main_entrance = region.get_connecting_entrance(is_main_entrance)
+                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
+        hint_data.update(er_hint_data)
+
     def modify_multidata(self, multidata: dict):
         import base64
         # wait for self.rom_name to be available.
@@ -419,8 +440,7 @@ class ALTTPWorld(World):
         return ALttPItem(name, self.player, **item_init_table[name])
 
     @classmethod
-    def stage_fill_hook(cls, world, progitempool, nonexcludeditempool, localrestitempool, nonlocalrestitempool,
-                        restitempool, fill_locations):
+    def stage_fill_hook(cls, world, progitempool, usefulitempool, filleritempool, fill_locations):
         trash_counts = {}
         standard_keyshuffle_players = set()
         for player in world.get_game_players("A Link to the Past"):
@@ -467,26 +487,15 @@ class ALTTPWorld(World):
             for player, trash_count in trash_counts.items():
                 gtower_locations = locations_mapping[player]
                 world.random.shuffle(gtower_locations)
-                localrest = localrestitempool[player]
-                if localrest:
-                    gt_item_pool = restitempool + localrest
-                    world.random.shuffle(gt_item_pool)
-                else:
-                    gt_item_pool = restitempool.copy()
 
-                while gtower_locations and gt_item_pool and trash_count > 0:
+                while gtower_locations and filleritempool and trash_count > 0:
                     spot_to_fill = gtower_locations.pop()
-                    item_to_place = gt_item_pool.pop()
+                    item_to_place = filleritempool.pop()
                     if spot_to_fill.item_rule(item_to_place):
-                        if item_to_place in localrest:
-                            localrest.remove(item_to_place)
-                        else:
-                            restitempool.remove(item_to_place)
                         world.push_item(spot_to_fill, item_to_place, False)
                         fill_locations.remove(spot_to_fill)  # very slow, unfortunately
                         trash_count -= 1
 
-
     def get_filler_item_name(self) -> str:
         if self.world.goal[self.player] == "icerodhunt":
             item = "Nothing"

worlds/alttp/docs/plando_en.md

@@ -26,10 +26,14 @@
         - Example: `Trinexx`
         - Takes a particular boss and places that boss in any remaining slots in which this boss can function.
         - In this example, it would fill Desert Palace, but not Tower of Hera.
+        - If no other options are provided this will follow normal singularity rules with that boss.
     - Boss Shuffle:
-        - Example: `simple`
+        - Example: `basic`
             - Runs a particular boss shuffle mode to finish construction instead of vanilla placement, typically used as
               a last instruction.
+            - Supports `random` which will choose a random option from the normal choices.
+            - If one is not supplied any remaining locations will be unshuffled unless a single specific boss is
+              supplied in which case it will use singularity as noted above.
 - [Available Bosses](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/Bosses.py#L135)
 - [Available Arenas](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/Bosses.py#L150)
 

worlds/dkc3/Client.py

@@ -66,7 +66,7 @@ async def dkc3_game_watcher(ctx: Context):
             return
 
         new_checks = []
-        from worlds.dkc3.Rom import location_rom_data, item_rom_data
+        from worlds.dkc3.Rom import location_rom_data, item_rom_data, boss_location_ids, level_unlock_map
         for loc_id, loc_data in location_rom_data.items():
             if loc_id not in ctx.locations_checked:
                 data = await snes_read(ctx, WRAM_START + loc_data[0], 1)
@@ -186,22 +186,40 @@ async def dkc3_game_watcher(ctx: Context):
 
         # DKC3_TODO: This method of collect should work, however it does not unlock the next level correctly when previous is flagged
         # Handle Collected Locations
-        #for loc_id in ctx.checked_locations:
-        #    if loc_id not in ctx.locations_checked:
-        #        loc_data = location_rom_data[loc_id]
-        #        data = await snes_read(ctx, WRAM_START + loc_data[0], 1)
-        #        invert_bit = ((len(loc_data) >= 3) and loc_data[2])
-        #        if not invert_bit:
-        #            masked_data = data[0] | (1 << loc_data[1])
-        #            print("Collected Location: ", hex(loc_data[0]), " | ", loc_data[1])
-        #            snes_buffered_write(ctx, WRAM_START + loc_data[0], bytes([masked_data]))
-        #            await snes_flush_writes(ctx)
-        #        else:
-        #            masked_data = data[0] & ~(1 << loc_data[1])
-        #            print("Collected Inverted Location: ", hex(loc_data[0]), " | ", loc_data[1])
-        #            snes_buffered_write(ctx, WRAM_START + loc_data[0], bytes([masked_data]))
-        #            await snes_flush_writes(ctx)
-        #        ctx.locations_checked.add(loc_id)
+        for loc_id in ctx.checked_locations:
+            if loc_id not in ctx.locations_checked and loc_id not in boss_location_ids:
+                loc_data = location_rom_data[loc_id]
+                data = await snes_read(ctx, WRAM_START + loc_data[0], 1)
+                invert_bit = ((len(loc_data) >= 3) and loc_data[2])
+                if not invert_bit:
+                    masked_data = data[0] | (1 << loc_data[1])
+                    #print("Collected Location: ", hex(loc_data[0]), " | ", loc_data[1])
+                    snes_buffered_write(ctx, WRAM_START + loc_data[0], bytes([masked_data]))
+
+                    if (loc_data[1] == 1):
+                        # Make the next levels accessible
+                        level_id = loc_data[0] - 0x632
+                        levels_to_tiles = await snes_read(ctx, ROM_START + 0x3FF800, 0x60)
+                        tiles_to_levels = await snes_read(ctx, ROM_START + 0x3FF860, 0x60)
+                        tile_id = levels_to_tiles[level_id] if levels_to_tiles[level_id] != 0xFF else level_id
+                        tile_id = tile_id + 0x632
+                        #print("Tile ID: ", hex(tile_id))
+                        if tile_id in level_unlock_map:
+                            for next_level_address in level_unlock_map[tile_id]:
+                                next_level_id = next_level_address - 0x632
+                                next_tile_id = tiles_to_levels[next_level_id] if tiles_to_levels[next_level_id] != 0xFF else next_level_id
+                                next_tile_id = next_tile_id + 0x632
+                                #print("Next Level ID: ", hex(next_tile_id))
+                                next_data = await snes_read(ctx, WRAM_START + next_tile_id, 1)
+                                snes_buffered_write(ctx, WRAM_START + next_tile_id, bytes([next_data[0] | 0x01]))
+
+                    await snes_flush_writes(ctx)
+                else:
+                    masked_data = data[0] & ~(1 << loc_data[1])
+                    print("Collected Inverted Location: ", hex(loc_data[0]), " | ", loc_data[1])
+                    snes_buffered_write(ctx, WRAM_START + loc_data[0], bytes([masked_data]))
+                    await snes_flush_writes(ctx)
+                ctx.locations_checked.add(loc_id)
 
         # Calculate Boomer Cost Text
         boomer_cost_text = await snes_read(ctx, WRAM_START + 0xAAFD, 2)

worlds/dkc3/Locations.py

@@ -221,6 +221,55 @@ level_location_table = {
     LocationName.rocket_rush_dk:      0xDC30A0,
 }
 
+kong_location_table = {
+    LocationName.lakeside_limbo_kong: 0xDC3100,
+    LocationName.doorstop_dash_kong:  0xDC3104,
+    LocationName.tidal_trouble_kong:  0xDC3108,
+    LocationName.skiddas_row_kong:    0xDC310C,
+    LocationName.murky_mill_kong:     0xDC3110,
+
+    LocationName.barrel_shield_bust_up_kong: 0xDC3114,
+    LocationName.riverside_race_kong:        0xDC3118,
+    LocationName.squeals_on_wheels_kong:     0xDC311C,
+    LocationName.springin_spiders_kong:      0xDC3120,
+    LocationName.bobbing_barrel_brawl_kong:  0xDC3124,
+
+    LocationName.bazzas_blockade_kong:     0xDC3128,
+    LocationName.rocket_barrel_ride_kong:  0xDC312C,
+    LocationName.kreeping_klasps_kong:     0xDC3130,
+    LocationName.tracker_barrel_trek_kong: 0xDC3134,
+    LocationName.fish_food_frenzy_kong:    0xDC3138,
+
+    LocationName.fire_ball_frenzy_kong:      0xDC313C,
+    LocationName.demolition_drain_pipe_kong: 0xDC3140,
+    LocationName.ripsaw_rage_kong:           0xDC3144,
+    LocationName.blazing_bazookas_kong:      0xDC3148,
+    LocationName.low_g_labyrinth_kong:       0xDC314C,
+
+    LocationName.krevice_kreepers_kong:   0xDC3150,
+    LocationName.tearaway_toboggan_kong:  0xDC3154,
+    LocationName.barrel_drop_bounce_kong: 0xDC3158,
+    LocationName.krack_shot_kroc_kong:    0xDC315C,
+    LocationName.lemguin_lunge_kong:      0xDC3160,
+
+    LocationName.buzzer_barrage_kong:    0xDC3164,
+    LocationName.kong_fused_cliffs_kong: 0xDC3168,
+    LocationName.floodlit_fish_kong:     0xDC316C,
+    LocationName.pothole_panic_kong:     0xDC3170,
+    LocationName.ropey_rumpus_kong:      0xDC3174,
+
+    LocationName.konveyor_rope_clash_kong: 0xDC3178,
+    LocationName.creepy_caverns_kong:      0xDC317C,
+    LocationName.lightning_lookout_kong:   0xDC3180,
+    LocationName.koindozer_klamber_kong:   0xDC3184,
+    LocationName.poisonous_pipeline_kong:  0xDC3188,
+
+    LocationName.stampede_sprint_kong:    0xDC318C,
+    LocationName.criss_cross_cliffs_kong: 0xDC3191,
+    LocationName.tyrant_twin_tussle_kong: 0xDC3195,
+    LocationName.swoopy_salvo_kong:       0xDC319A,
+}
+
 
 boss_location_table = {
     LocationName.belchas_barn:     0xDC30A1,
@@ -266,6 +315,7 @@ all_locations = {
     **boss_location_table,
     **secret_cave_location_table,
     **brothers_bear_location_table,
+    **kong_location_table,
 }
 
 location_table = {}
@@ -277,6 +327,9 @@ def setup_locations(world, player: int):
     if False:#world.include_trade_sequence[player].value:
         location_table.update({**brothers_bear_location_table})
 
+    if world.kongsanity[player].value:
+        location_table.update({**kong_location_table})
+
     return location_table
 
 

worlds/dkc3/Names/LocationName.py

@@ -1,197 +1,236 @@
 # Level Definitions
 lakeside_limbo_flag    = "Lakeside Limbo - Flag"
+lakeside_limbo_kong    = "Lakeside Limbo - KONG"
 lakeside_limbo_bonus_1 = "Lakeside Limbo - Bonus 1"
 lakeside_limbo_bonus_2 = "Lakeside Limbo - Bonus 2"
 lakeside_limbo_dk      = "Lakeside Limbo - DK Coin"
 
 doorstop_dash_flag    = "Doorstop Dash - Flag"
+doorstop_dash_kong    = "Doorstop Dash - KONG"
 doorstop_dash_bonus_1 = "Doorstop Dash - Bonus 1"
 doorstop_dash_bonus_2 = "Doorstop Dash - Bonus 2"
 doorstop_dash_dk      = "Doorstop Dash - DK Coin"
 
 tidal_trouble_flag    = "Tidal Trouble - Flag"
+tidal_trouble_kong    = "Tidal Trouble - KONG"
 tidal_trouble_bonus_1 = "Tidal Trouble - Bonus 1"
 tidal_trouble_bonus_2 = "Tidal Trouble - Bonus 2"
 tidal_trouble_dk      = "Tidal Trouble - DK Coin"
 
 skiddas_row_flag    = "Skidda's Row - Flag"
+skiddas_row_kong    = "Skidda's Row - KONG"
 skiddas_row_bonus_1 = "Skidda's Row - Bonus 1"
 skiddas_row_bonus_2 = "Skidda's Row - Bonus 2"
 skiddas_row_dk      = "Skidda's Row - DK Coin"
 
 murky_mill_flag    = "Murky Mill - Flag"
+murky_mill_kong    = "Murky Mill - KONG"
 murky_mill_bonus_1 = "Murky Mill - Bonus 1"
 murky_mill_bonus_2 = "Murky Mill - Bonus 2"
 murky_mill_dk      = "Murky Mill - DK Coin"
 
 barrel_shield_bust_up_flag    = "Barrel Shield Bust-Up - Flag"
+barrel_shield_bust_up_kong    = "Barrel Shield Bust-Up - KONG"
 barrel_shield_bust_up_bonus_1 = "Barrel Shield Bust-Up - Bonus 1"
 barrel_shield_bust_up_bonus_2 = "Barrel Shield Bust-Up - Bonus 2"
 barrel_shield_bust_up_dk      = "Barrel Shield Bust-Up - DK Coin"
 
 riverside_race_flag    = "Riverside Race - Flag"
+riverside_race_kong    = "Riverside Race - KONG"
 riverside_race_bonus_1 = "Riverside Race - Bonus 1"
 riverside_race_bonus_2 = "Riverside Race - Bonus 2"
 riverside_race_dk      = "Riverside Race - DK Coin"
 
 squeals_on_wheels_flag    = "Squeals On Wheels - Flag"
+squeals_on_wheels_kong    = "Squeals On Wheels - KONG"
 squeals_on_wheels_bonus_1 = "Squeals On Wheels - Bonus 1"
 squeals_on_wheels_bonus_2 = "Squeals On Wheels - Bonus 2"
 squeals_on_wheels_dk      = "Squeals On Wheels - DK Coin"
 
 springin_spiders_flag    = "Springin' Spiders - Flag"
+springin_spiders_kong    = "Springin' Spiders - KONG"
 springin_spiders_bonus_1 = "Springin' Spiders - Bonus 1"
 springin_spiders_bonus_2 = "Springin' Spiders - Bonus 2"
 springin_spiders_dk      = "Springin' Spiders - DK Coin"
 
 bobbing_barrel_brawl_flag    = "Bobbing Barrel Brawl - Flag"
+bobbing_barrel_brawl_kong    = "Bobbing Barrel Brawl - KONG"
 bobbing_barrel_brawl_bonus_1 = "Bobbing Barrel Brawl - Bonus 1"
 bobbing_barrel_brawl_bonus_2 = "Bobbing Barrel Brawl - Bonus 2"
 bobbing_barrel_brawl_dk      = "Bobbing Barrel Brawl - DK Coin"
 
 bazzas_blockade_flag    = "Bazza's Blockade - Flag"
+bazzas_blockade_kong    = "Bazza's Blockade - KONG"
 bazzas_blockade_bonus_1 = "Bazza's Blockade - Bonus 1"
 bazzas_blockade_bonus_2 = "Bazza's Blockade - Bonus 2"
 bazzas_blockade_dk      = "Bazza's Blockade - DK Coin"
 
 rocket_barrel_ride_flag    = "Rocket Barrel Ride - Flag"
+rocket_barrel_ride_kong    = "Rocket Barrel Ride - KONG"
 rocket_barrel_ride_bonus_1 = "Rocket Barrel Ride - Bonus 1"
 rocket_barrel_ride_bonus_2 = "Rocket Barrel Ride - Bonus 2"
 rocket_barrel_ride_dk      = "Rocket Barrel Ride - DK Coin"
 
 kreeping_klasps_flag    = "Kreeping Klasps - Flag"
+kreeping_klasps_kong    = "Kreeping Klasps - KONG"
 kreeping_klasps_bonus_1 = "Kreeping Klasps - Bonus 1"
 kreeping_klasps_bonus_2 = "Kreeping Klasps - Bonus 2"
 kreeping_klasps_dk      = "Kreeping Klasps - DK Coin"
 
 tracker_barrel_trek_flag    = "Tracker Barrel Trek - Flag"
+tracker_barrel_trek_kong    = "Tracker Barrel Trek - KONG"
 tracker_barrel_trek_bonus_1 = "Tracker Barrel Trek - Bonus 1"
 tracker_barrel_trek_bonus_2 = "Tracker Barrel Trek - Bonus 2"
 tracker_barrel_trek_dk      = "Tracker Barrel Trek - DK Coin"
 
 fish_food_frenzy_flag    = "Fish Food Frenzy - Flag"
+fish_food_frenzy_kong    = "Fish Food Frenzy - KONG"
 fish_food_frenzy_bonus_1 = "Fish Food Frenzy - Bonus 1"
 fish_food_frenzy_bonus_2 = "Fish Food Frenzy - Bonus 2"
 fish_food_frenzy_dk      = "Fish Food Frenzy - DK Coin"
 
 fire_ball_frenzy_flag    = "Fire-Ball Frenzy - Flag"
+fire_ball_frenzy_kong    = "Fire-Ball Frenzy - KONG"
 fire_ball_frenzy_bonus_1 = "Fire-Ball Frenzy - Bonus 1"
 fire_ball_frenzy_bonus_2 = "Fire-Ball Frenzy - Bonus 2"
 fire_ball_frenzy_dk      = "Fire-Ball Frenzy - DK Coin"
 
 demolition_drain_pipe_flag    = "Demolition Drain-Pipe - Flag"
+demolition_drain_pipe_kong    = "Demolition Drain-Pipe - KONG"
 demolition_drain_pipe_bonus_1 = "Demolition Drain-Pipe - Bonus 1"
 demolition_drain_pipe_bonus_2 = "Demolition Drain-Pipe - Bonus 2"
 demolition_drain_pipe_dk      = "Demolition Drain-Pipe - DK Coin"
 
 ripsaw_rage_flag    = "Ripsaw Rage - Flag"
+ripsaw_rage_kong    = "Ripsaw Rage - KONG"
 ripsaw_rage_bonus_1 = "Ripsaw Rage - Bonus 1"
 ripsaw_rage_bonus_2 = "Ripsaw Rage - Bonus 2"
 ripsaw_rage_dk      = "Ripsaw Rage - DK Coin"
 
-blazing_bazookas_flag    = "Blazing Bazookas - Flag"
-blazing_bazookas_bonus_1 = "Blazing Bazookas - Bonus 1"
-blazing_bazookas_bonus_2 = "Blazing Bazookas - Bonus 2"
-blazing_bazookas_dk      = "Blazing Bazookas - DK Coin"
+blazing_bazookas_flag    = "Blazing Bazukas - Flag"
+blazing_bazookas_kong    = "Blazing Bazukas - KONG"
+blazing_bazookas_bonus_1 = "Blazing Bazukas - Bonus 1"
+blazing_bazookas_bonus_2 = "Blazing Bazukas - Bonus 2"
+blazing_bazookas_dk      = "Blazing Bazukas - DK Coin"
 
 low_g_labyrinth_flag    = "Low-G Labyrinth - Flag"
+low_g_labyrinth_kong    = "Low-G Labyrinth - KONG"
 low_g_labyrinth_bonus_1 = "Low-G Labyrinth - Bonus 1"
 low_g_labyrinth_bonus_2 = "Low-G Labyrinth - Bonus 2"
 low_g_labyrinth_dk      = "Low-G Labyrinth - DK Coin"
 
 krevice_kreepers_flag    = "Krevice Kreepers - Flag"
+krevice_kreepers_kong    = "Krevice Kreepers - KONG"
 krevice_kreepers_bonus_1 = "Krevice Kreepers - Bonus 1"
 krevice_kreepers_bonus_2 = "Krevice Kreepers - Bonus 2"
 krevice_kreepers_dk      = "Krevice Kreepers - DK Coin"
 
 tearaway_toboggan_flag    = "Tearaway Toboggan - Flag"
+tearaway_toboggan_kong    = "Tearaway Toboggan - KONG"
 tearaway_toboggan_bonus_1 = "Tearaway Toboggan - Bonus 1"
 tearaway_toboggan_bonus_2 = "Tearaway Toboggan - Bonus 2"
 tearaway_toboggan_dk      = "Tearaway Toboggan - DK Coin"
 
 barrel_drop_bounce_flag    = "Barrel Drop Bounce - Flag"
+barrel_drop_bounce_kong    = "Barrel Drop Bounce - KONG"
 barrel_drop_bounce_bonus_1 = "Barrel Drop Bounce - Bonus 1"
 barrel_drop_bounce_bonus_2 = "Barrel Drop Bounce - Bonus 2"
 barrel_drop_bounce_dk      = "Barrel Drop Bounce - DK Coin"
 
 krack_shot_kroc_flag    = "Krack-Shot Kroc - Flag"
+krack_shot_kroc_kong    = "Krack-Shot Kroc - KONG"
 krack_shot_kroc_bonus_1 = "Krack-Shot Kroc - Bonus 1"
 krack_shot_kroc_bonus_2 = "Krack-Shot Kroc - Bonus 2"
 krack_shot_kroc_dk      = "Krack-Shot Kroc - DK Coin"
 
 lemguin_lunge_flag    = "Lemguin Lunge - Flag"
+lemguin_lunge_kong    = "Lemguin Lunge - KONG"
 lemguin_lunge_bonus_1 = "Lemguin Lunge - Bonus 1"
 lemguin_lunge_bonus_2 = "Lemguin Lunge - Bonus 2"
 lemguin_lunge_dk      = "Lemguin Lunge - DK Coin"
 
 buzzer_barrage_flag    = "Buzzer Barrage - Flag"
+buzzer_barrage_kong    = "Buzzer Barrage - KONG"
 buzzer_barrage_bonus_1 = "Buzzer Barrage - Bonus 1"
 buzzer_barrage_bonus_2 = "Buzzer Barrage - Bonus 2"
 buzzer_barrage_dk      = "Buzzer Barrage - DK Coin"
 
 kong_fused_cliffs_flag    = "Kong-Fused Cliffs - Flag"
+kong_fused_cliffs_kong    = "Kong-Fused Cliffs - KONG"
 kong_fused_cliffs_bonus_1 = "Kong-Fused Cliffs - Bonus 1"
 kong_fused_cliffs_bonus_2 = "Kong-Fused Cliffs - Bonus 2"
 kong_fused_cliffs_dk      = "Kong-Fused Cliffs - DK Coin"
 
 floodlit_fish_flag    = "Floodlit Fish - Flag"
+floodlit_fish_kong    = "Floodlit Fish - KONG"
 floodlit_fish_bonus_1 = "Floodlit Fish - Bonus 1"
 floodlit_fish_bonus_2 = "Floodlit Fish - Bonus 2"
 floodlit_fish_dk      = "Floodlit Fish - DK Coin"
 
 pothole_panic_flag    = "Pothole Panic - Flag"
+pothole_panic_kong    = "Pothole Panic - KONG"
 pothole_panic_bonus_1 = "Pothole Panic - Bonus 1"
 pothole_panic_bonus_2 = "Pothole Panic - Bonus 2"
 pothole_panic_dk      = "Pothole Panic - DK Coin"
 
 ropey_rumpus_flag    = "Ropey Rumpus - Flag"
+ropey_rumpus_kong    = "Ropey Rumpus - KONG"
 ropey_rumpus_bonus_1 = "Ropey Rumpus - Bonus 1"
 ropey_rumpus_bonus_2 = "Ropey Rumpus - Bonus 2"
 ropey_rumpus_dk      = "Ropey Rumpus - DK Coin"
 
 konveyor_rope_clash_flag    = "Konveyor Rope Klash - Flag"
+konveyor_rope_clash_kong    = "Konveyor Rope Klash - KONG"
 konveyor_rope_clash_bonus_1 = "Konveyor Rope Klash - Bonus 1"
 konveyor_rope_clash_bonus_2 = "Konveyor Rope Klash - Bonus 2"
 konveyor_rope_clash_dk      = "Konveyor Rope Klash - DK Coin"
 
 creepy_caverns_flag    = "Creepy Caverns - Flag"
+creepy_caverns_kong    = "Creepy Caverns - KONG"
 creepy_caverns_bonus_1 = "Creepy Caverns - Bonus 1"
 creepy_caverns_bonus_2 = "Creepy Caverns - Bonus 2"
 creepy_caverns_dk      = "Creepy Caverns - DK Coin"
 
 lightning_lookout_flag    = "Lightning Lookout - Flag"
+lightning_lookout_kong    = "Lightning Lookout - KONG"
 lightning_lookout_bonus_1 = "Lightning Lookout - Bonus 1"
 lightning_lookout_bonus_2 = "Lightning Lookout - Bonus 2"
 lightning_lookout_dk      = "Lightning Lookout - DK Coin"
 
 koindozer_klamber_flag    = "Koindozer Klamber - Flag"
+koindozer_klamber_kong    = "Koindozer Klamber - KONG"
 koindozer_klamber_bonus_1 = "Koindozer Klamber - Bonus 1"
 koindozer_klamber_bonus_2 = "Koindozer Klamber - Bonus 2"
 koindozer_klamber_dk      = "Koindozer Klamber - DK Coin"
 
 poisonous_pipeline_flag    = "Poisonous Pipeline - Flag"
+poisonous_pipeline_kong    = "Poisonous Pipeline - KONG"
 poisonous_pipeline_bonus_1 = "Poisonous Pipeline - Bonus 1"
 poisonous_pipeline_bonus_2 = "Poisonous Pipeline - Bonus 2"
 poisonous_pipeline_dk      = "Poisonous Pipeline - DK Coin"
 
 stampede_sprint_flag    = "Stampede Sprint - Flag"
+stampede_sprint_kong    = "Stampede Sprint - KONG"
 stampede_sprint_bonus_1 = "Stampede Sprint - Bonus 1"
 stampede_sprint_bonus_2 = "Stampede Sprint - Bonus 2"
 stampede_sprint_bonus_3 = "Stampede Sprint - Bonus 3"
 stampede_sprint_dk      = "Stampede Sprint - DK Coin"
 
 criss_cross_cliffs_flag    = "Criss Kross Cliffs - Flag"
+criss_cross_cliffs_kong    = "Criss Kross Cliffs - KONG"
 criss_cross_cliffs_bonus_1 = "Criss Kross Cliffs - Bonus 1"
 criss_cross_cliffs_bonus_2 = "Criss Kross Cliffs - Bonus 2"
 criss_cross_cliffs_dk      = "Criss Kross Cliffs - DK Coin"
 
 tyrant_twin_tussle_flag    = "Tyrant Twin Tussle - Flag"
+tyrant_twin_tussle_kong    = "Tyrant Twin Tussle - KONG"
 tyrant_twin_tussle_bonus_1 = "Tyrant Twin Tussle - Bonus 1"
 tyrant_twin_tussle_bonus_2 = "Tyrant Twin Tussle - Bonus 2"
 tyrant_twin_tussle_bonus_3 = "Tyrant Twin Tussle - Bonus 3"
 tyrant_twin_tussle_dk      = "Tyrant Twin Tussle - DK Coin"
 
 swoopy_salvo_flag    = "Swoopy Salvo - Flag"
+swoopy_salvo_kong    = "Swoopy Salvo - KONG"
 swoopy_salvo_bonus_1 = "Swoopy Salvo - Bonus 1"
 swoopy_salvo_bonus_2 = "Swoopy Salvo - Bonus 2"
 swoopy_salvo_bonus_3 = "Swoopy Salvo - Bonus 3"

worlds/dkc3/Options.py

@@ -6,7 +6,7 @@ from Options import Choice, Range, Option, Toggle, DeathLink, DefaultOnToggle, O
 class Goal(Choice):
     """
     Determines the goal of the seed
-    Knautilus: Reach the Knautilus and defeat Baron K. Roolenstein
+    Knautilus: Scuttle the Knautilus in Krematoa and defeat Baron K. Roolenstein
     Banana Bird Hunt: Find a certain number of Banana Birds and rescue their mother
     """
     display_name = "Goal"
@@ -75,6 +75,13 @@ class PercentageOfBananaBirds(Range):
     default = 100
 
 
+class KONGsanity(Toggle):
+    """
+    Whether collecting all four KONG letters in each level grants a check
+    """
+    display_name = "KONGsanity"
+
+
 class LevelShuffle(Toggle):
     """
     Whether levels are shuffled
@@ -82,6 +89,41 @@ class LevelShuffle(Toggle):
     display_name = "Level Shuffle"
 
 
+class Difficulty(Choice):
+    """
+    Which Difficulty Level to use
+    NORML: The Normal Difficulty
+    HARDR: Many DK Barrels are removed
+    TUFST: Most DK Barrels and all Midway Barrels are removed
+    """
+    display_name = "Difficulty"
+    option_norml = 0
+    option_hardr = 1
+    option_tufst = 2
+    default = 0
+
+    @classmethod
+    def get_option_name(cls, value) -> str:
+        if cls.auto_display_name:
+            return cls.name_lookup[value].upper()
+        else:
+            return cls.name_lookup[value]
+
+
+class Autosave(DefaultOnToggle):
+    """
+    Whether the game should autosave after each level
+    """
+    display_name = "Autosave"
+
+
+class MERRY(Toggle):
+    """
+    Whether the Bonus Barrels will be Christmas-themed
+    """
+    display_name = "MERRY"
+
+
 class MusicShuffle(Toggle):
     """
     Whether music is shuffled
@@ -125,7 +167,11 @@ dkc3_options: typing.Dict[str, type(Option)] = {
     "percentage_of_extra_bonus_coins": PercentageOfExtraBonusCoins,
     "number_of_banana_birds": NumberOfBananaBirds,
     "percentage_of_banana_birds": PercentageOfBananaBirds,
+    "kongsanity": KONGsanity,
     "level_shuffle": LevelShuffle,
+    "difficulty": Difficulty,
+    "autosave": Autosave,
+    "merry": MERRY,
     "music_shuffle": MusicShuffle,
     "kong_palette_swap": KongPaletteSwap,
     "starting_life_count": StartingLifeCount,

worlds/dkc3/Regions.py

@@ -44,6 +44,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.lakeside_limbo_bonus_2 : [0x657, 3],
         LocationName.lakeside_limbo_dk      : [0x657, 5],
     }
+    if world.kongsanity[player]:
+        lakeside_limbo_region_locations[LocationName.lakeside_limbo_kong] = []
     lakeside_limbo_region = create_region(world, player, active_locations, LocationName.lakeside_limbo_region,
                                           lakeside_limbo_region_locations, None)
 
@@ -53,6 +55,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.doorstop_dash_bonus_2 : [0x65A, 3],
         LocationName.doorstop_dash_dk      : [0x65A, 5],
     }
+    if world.kongsanity[player]:
+        doorstop_dash_region_locations[LocationName.doorstop_dash_kong] = []
     doorstop_dash_region = create_region(world, player, active_locations, LocationName.doorstop_dash_region,
                                          doorstop_dash_region_locations, None)
 
@@ -62,6 +66,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.tidal_trouble_bonus_2 : [0x659, 3],
         LocationName.tidal_trouble_dk      : [0x659, 5],
     }
+    if world.kongsanity[player]:
+        tidal_trouble_region_locations[LocationName.tidal_trouble_kong] = []
     tidal_trouble_region = create_region(world, player, active_locations, LocationName.tidal_trouble_region,
                                          tidal_trouble_region_locations, None)
 
@@ -71,6 +77,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.skiddas_row_bonus_2 : [0x65D, 3],
         LocationName.skiddas_row_dk      : [0x65D, 5],
     }
+    if world.kongsanity[player]:
+        skiddas_row_region_locations[LocationName.skiddas_row_kong] = []
     skiddas_row_region = create_region(world, player, active_locations, LocationName.skiddas_row_region,
                                        skiddas_row_region_locations, None)
 
@@ -80,6 +88,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.murky_mill_bonus_2 : [0x65C, 3],
         LocationName.murky_mill_dk      : [0x65C, 5],
     }
+    if world.kongsanity[player]:
+        murky_mill_region_locations[LocationName.murky_mill_kong] = []
     murky_mill_region = create_region(world, player, active_locations, LocationName.murky_mill_region,
                                       murky_mill_region_locations, None)
 
@@ -89,6 +99,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.barrel_shield_bust_up_bonus_2  : [0x662, 3],
         LocationName.barrel_shield_bust_up_dk       : [0x662, 5],
     }
+    if world.kongsanity[player]:
+        barrel_shield_bust_up_region_locations[LocationName.barrel_shield_bust_up_kong] = []
     barrel_shield_bust_up_region = create_region(world, player, active_locations, LocationName.barrel_shield_bust_up_region,
                                                  barrel_shield_bust_up_region_locations, None)
 
@@ -98,6 +110,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.riverside_race_bonus_2 : [0x664, 3],
         LocationName.riverside_race_dk      : [0x664, 5],
     }
+    if world.kongsanity[player]:
+        riverside_race_region_locations[LocationName.riverside_race_kong] = []
     riverside_race_region = create_region(world, player, active_locations, LocationName.riverside_race_region,
                                           riverside_race_region_locations, None)
 
@@ -107,6 +121,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.squeals_on_wheels_bonus_2 : [0x65B, 3],
         LocationName.squeals_on_wheels_dk      : [0x65B, 5],
     }
+    if world.kongsanity[player]:
+        squeals_on_wheels_region_locations[LocationName.squeals_on_wheels_kong] = []
     squeals_on_wheels_region = create_region(world, player, active_locations, LocationName.squeals_on_wheels_region,
                                              squeals_on_wheels_region_locations, None)
 
@@ -116,6 +132,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.springin_spiders_bonus_2 : [0x661, 3],
         LocationName.springin_spiders_dk      : [0x661, 5],
     }
+    if world.kongsanity[player]:
+        springin_spiders_region_locations[LocationName.springin_spiders_kong] = []
     springin_spiders_region = create_region(world, player, active_locations, LocationName.springin_spiders_region,
                                             springin_spiders_region_locations, None)
 
@@ -125,6 +143,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.bobbing_barrel_brawl_bonus_2  : [0x666, 3],
         LocationName.bobbing_barrel_brawl_dk       : [0x666, 5],
     }
+    if world.kongsanity[player]:
+        bobbing_barrel_brawl_region_locations[LocationName.bobbing_barrel_brawl_kong] = []
     bobbing_barrel_brawl_region = create_region(world, player, active_locations, LocationName.bobbing_barrel_brawl_region,
                                                 bobbing_barrel_brawl_region_locations, None)
 
@@ -134,6 +154,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.bazzas_blockade_bonus_2 : [0x667, 3],
         LocationName.bazzas_blockade_dk      : [0x667, 5],
     }
+    if world.kongsanity[player]:
+        bazzas_blockade_region_locations[LocationName.bazzas_blockade_kong] = []
     bazzas_blockade_region = create_region(world, player, active_locations, LocationName.bazzas_blockade_region,
                                            bazzas_blockade_region_locations, None)
 
@@ -143,6 +165,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.rocket_barrel_ride_bonus_2 : [0x66A, 3],
         LocationName.rocket_barrel_ride_dk      : [0x66A, 5],
     }
+    if world.kongsanity[player]:
+        rocket_barrel_ride_region_locations[LocationName.rocket_barrel_ride_kong] = []
     rocket_barrel_ride_region = create_region(world, player, active_locations, LocationName.rocket_barrel_ride_region,
                                               rocket_barrel_ride_region_locations, None)
 
@@ -152,6 +176,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.kreeping_klasps_bonus_2  : [0x658, 3],
         LocationName.kreeping_klasps_dk       : [0x658, 5],
     }
+    if world.kongsanity[player]:
+        kreeping_klasps_region_locations[LocationName.kreeping_klasps_kong] = []
     kreeping_klasps_region = create_region(world, player, active_locations, LocationName.kreeping_klasps_region,
                                            kreeping_klasps_region_locations, None)
 
@@ -161,6 +187,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.tracker_barrel_trek_bonus_2 : [0x66B, 3],
         LocationName.tracker_barrel_trek_dk      : [0x66B, 5],
     }
+    if world.kongsanity[player]:
+        tracker_barrel_trek_region_locations[LocationName.tracker_barrel_trek_kong] = []
     tracker_barrel_trek_region = create_region(world, player, active_locations, LocationName.tracker_barrel_trek_region,
                                                tracker_barrel_trek_region_locations, None)
 
@@ -170,6 +198,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.fish_food_frenzy_bonus_2 : [0x668, 3],
         LocationName.fish_food_frenzy_dk      : [0x668, 5],
     }
+    if world.kongsanity[player]:
+        fish_food_frenzy_region_locations[LocationName.fish_food_frenzy_kong] = []
     fish_food_frenzy_region = create_region(world, player, active_locations, LocationName.fish_food_frenzy_region,
                                             fish_food_frenzy_region_locations, None)
 
@@ -179,6 +209,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.fire_ball_frenzy_bonus_2 : [0x66D, 3],
         LocationName.fire_ball_frenzy_dk      : [0x66D, 5],
     }
+    if world.kongsanity[player]:
+        fire_ball_frenzy_region_locations[LocationName.fire_ball_frenzy_kong] = []
     fire_ball_frenzy_region = create_region(world, player, active_locations, LocationName.fire_ball_frenzy_region,
                                             fire_ball_frenzy_region_locations, None)
 
@@ -188,6 +220,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.demolition_drain_pipe_bonus_2 : [0x672, 3],
         LocationName.demolition_drain_pipe_dk      : [0x672, 5],
     }
+    if world.kongsanity[player]:
+        demolition_drain_pipe_region_locations[LocationName.demolition_drain_pipe_kong] = []
     demolition_drain_pipe_region = create_region(world, player, active_locations, LocationName.demolition_drain_pipe_region,
                                                  demolition_drain_pipe_region_locations, None)
 
@@ -197,6 +231,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.ripsaw_rage_bonus_2 : [0x660, 3],
         LocationName.ripsaw_rage_dk      : [0x660, 5],
     }
+    if world.kongsanity[player]:
+        ripsaw_rage_region_locations[LocationName.ripsaw_rage_kong] = []
     ripsaw_rage_region = create_region(world, player, active_locations, LocationName.ripsaw_rage_region,
                                        ripsaw_rage_region_locations, None)
 
@@ -206,6 +242,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.blazing_bazookas_bonus_2 : [0x66E, 3],
         LocationName.blazing_bazookas_dk      : [0x66E, 5],
     }
+    if world.kongsanity[player]:
+        blazing_bazookas_region_locations[LocationName.blazing_bazookas_kong] = []
     blazing_bazookas_region = create_region(world, player, active_locations, LocationName.blazing_bazookas_region,
                                             blazing_bazookas_region_locations, None)
 
@@ -215,6 +253,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.low_g_labyrinth_bonus_2  : [0x670, 3],
         LocationName.low_g_labyrinth_dk       : [0x670, 5],
     }
+    if world.kongsanity[player]:
+        low_g_labyrinth_region_locations[LocationName.low_g_labyrinth_kong] = []
     low_g_labyrinth_region = create_region(world, player, active_locations, LocationName.low_g_labyrinth_region,
                                            low_g_labyrinth_region_locations, None)
 
@@ -224,6 +264,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.krevice_kreepers_bonus_2 : [0x673, 3],
         LocationName.krevice_kreepers_dk      : [0x673, 5],
     }
+    if world.kongsanity[player]:
+        krevice_kreepers_region_locations[LocationName.krevice_kreepers_kong] = []
     krevice_kreepers_region = create_region(world, player, active_locations, LocationName.krevice_kreepers_region,
                                             krevice_kreepers_region_locations, None)
 
@@ -233,6 +275,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.tearaway_toboggan_bonus_2 : [0x65F, 3],
         LocationName.tearaway_toboggan_dk      : [0x65F, 5],
     }
+    if world.kongsanity[player]:
+        tearaway_toboggan_region_locations[LocationName.tearaway_toboggan_kong] = []
     tearaway_toboggan_region = create_region(world, player, active_locations, LocationName.tearaway_toboggan_region,
                                              tearaway_toboggan_region_locations, None)
 
@@ -242,6 +286,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.barrel_drop_bounce_bonus_2 : [0x66C, 3],
         LocationName.barrel_drop_bounce_dk      : [0x66C, 5],
     }
+    if world.kongsanity[player]:
+        barrel_drop_bounce_region_locations[LocationName.barrel_drop_bounce_kong] = []
     barrel_drop_bounce_region = create_region(world, player, active_locations, LocationName.barrel_drop_bounce_region,
                                               barrel_drop_bounce_region_locations, None)
 
@@ -251,6 +297,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.krack_shot_kroc_bonus_2 : [0x66F, 3],
         LocationName.krack_shot_kroc_dk      : [0x66F, 5],
     }
+    if world.kongsanity[player]:
+        krack_shot_kroc_region_locations[LocationName.krack_shot_kroc_kong] = []
     krack_shot_kroc_region = create_region(world, player, active_locations, LocationName.krack_shot_kroc_region,
                                            krack_shot_kroc_region_locations, None)
 
@@ -260,6 +308,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.lemguin_lunge_bonus_2 : [0x65E, 3],
         LocationName.lemguin_lunge_dk      : [0x65E, 5],
     }
+    if world.kongsanity[player]:
+        lemguin_lunge_region_locations[LocationName.lemguin_lunge_kong] = []
     lemguin_lunge_region = create_region(world, player, active_locations, LocationName.lemguin_lunge_region,
                                          lemguin_lunge_region_locations, None)
 
@@ -269,6 +319,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.buzzer_barrage_bonus_2 : [0x676, 3],
         LocationName.buzzer_barrage_dk      : [0x676, 5],
     }
+    if world.kongsanity[player]:
+        buzzer_barrage_region_locations[LocationName.buzzer_barrage_kong] = []
     buzzer_barrage_region = create_region(world, player, active_locations, LocationName.buzzer_barrage_region,
                                           buzzer_barrage_region_locations, None)
 
@@ -278,6 +330,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.kong_fused_cliffs_bonus_2 : [0x674, 3],
         LocationName.kong_fused_cliffs_dk      : [0x674, 5],
     }
+    if world.kongsanity[player]:
+        kong_fused_cliffs_region_locations[LocationName.kong_fused_cliffs_kong] = []
     kong_fused_cliffs_region = create_region(world, player, active_locations, LocationName.kong_fused_cliffs_region,
                                              kong_fused_cliffs_region_locations, None)
 
@@ -287,6 +341,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.floodlit_fish_bonus_2 : [0x669, 3],
         LocationName.floodlit_fish_dk      : [0x669, 5],
     }
+    if world.kongsanity[player]:
+        floodlit_fish_region_locations[LocationName.floodlit_fish_kong] = []
     floodlit_fish_region = create_region(world, player, active_locations, LocationName.floodlit_fish_region,
                                          floodlit_fish_region_locations, None)
 
@@ -296,6 +352,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.pothole_panic_bonus_2 : [0x677, 3],
         LocationName.pothole_panic_dk      : [0x677, 5],
     }
+    if world.kongsanity[player]:
+        pothole_panic_region_locations[LocationName.pothole_panic_kong] = []
     pothole_panic_region = create_region(world, player, active_locations, LocationName.pothole_panic_region,
                                          pothole_panic_region_locations, None)
 
@@ -305,6 +363,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.ropey_rumpus_bonus_2 : [0x675, 3],
         LocationName.ropey_rumpus_dk      : [0x675, 5],
     }
+    if world.kongsanity[player]:
+        ropey_rumpus_region_locations[LocationName.ropey_rumpus_kong] = []
     ropey_rumpus_region = create_region(world, player, active_locations, LocationName.ropey_rumpus_region,
                                         ropey_rumpus_region_locations, None)
 
@@ -314,6 +374,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.konveyor_rope_clash_bonus_2  : [0x657, 3],
         LocationName.konveyor_rope_clash_dk       : [0x657, 5],
     }
+    if world.kongsanity[player]:
+        konveyor_rope_clash_region_locations[LocationName.konveyor_rope_clash_kong] = []
     konveyor_rope_clash_region = create_region(world, player, active_locations, LocationName.konveyor_rope_clash_region,
                                                konveyor_rope_clash_region_locations, None)
 
@@ -323,6 +385,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.creepy_caverns_bonus_2 : [0x678, 3],
         LocationName.creepy_caverns_dk      : [0x678, 5],
     }
+    if world.kongsanity[player]:
+        creepy_caverns_region_locations[LocationName.creepy_caverns_kong] = []
     creepy_caverns_region = create_region(world, player, active_locations, LocationName.creepy_caverns_region,
                                           creepy_caverns_region_locations, None)
 
@@ -332,6 +396,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.lightning_lookout_bonus_2  : [0x665, 3],
         LocationName.lightning_lookout_dk       : [0x665, 5],
     }
+    if world.kongsanity[player]:
+        lightning_lookout_region_locations[LocationName.lightning_lookout_kong] = []
     lightning_lookout_region = create_region(world, player, active_locations, LocationName.lightning_lookout_region,
                                              lightning_lookout_region_locations, None)
 
@@ -341,6 +407,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.koindozer_klamber_bonus_2  : [0x679, 3],
         LocationName.koindozer_klamber_dk       : [0x679, 5],
     }
+    if world.kongsanity[player]:
+        koindozer_klamber_region_locations[LocationName.koindozer_klamber_kong] = []
     koindozer_klamber_region = create_region(world, player, active_locations, LocationName.koindozer_klamber_region,
                                              koindozer_klamber_region_locations, None)
 
@@ -350,6 +418,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.poisonous_pipeline_bonus_2 : [0x671, 3],
         LocationName.poisonous_pipeline_dk      : [0x671, 5],
     }
+    if world.kongsanity[player]:
+        poisonous_pipeline_region_locations[LocationName.poisonous_pipeline_kong] = []
     poisonous_pipeline_region = create_region(world, player, active_locations, LocationName.poisonous_pipeline_region,
                                               poisonous_pipeline_region_locations, None)
 
@@ -360,6 +430,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.stampede_sprint_bonus_3  : [0x67B, 4],
         LocationName.stampede_sprint_dk       : [0x67B, 5],
     }
+    if world.kongsanity[player]:
+        stampede_sprint_region_locations[LocationName.stampede_sprint_kong] = []
     stampede_sprint_region = create_region(world, player, active_locations, LocationName.stampede_sprint_region,
                                            stampede_sprint_region_locations, None)
 
@@ -369,6 +441,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.criss_cross_cliffs_bonus_2 : [0x67C, 3],
         LocationName.criss_cross_cliffs_dk      : [0x67C, 5],
     }
+    if world.kongsanity[player]:
+        criss_cross_cliffs_region_locations[LocationName.criss_cross_cliffs_kong] = []
     criss_cross_cliffs_region = create_region(world, player, active_locations, LocationName.criss_cross_cliffs_region,
                                               criss_cross_cliffs_region_locations, None)
 
@@ -379,6 +453,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.tyrant_twin_tussle_bonus_3 : [0x67D, 4],
         LocationName.tyrant_twin_tussle_dk      : [0x67D, 5],
     }
+    if world.kongsanity[player]:
+        tyrant_twin_tussle_region_locations[LocationName.tyrant_twin_tussle_kong] = []
     tyrant_twin_tussle_region = create_region(world, player, active_locations, LocationName.tyrant_twin_tussle_region,
                                               tyrant_twin_tussle_region_locations, None)
 
@@ -389,6 +465,8 @@ def create_regions(world, player: int, active_locations):
         LocationName.swoopy_salvo_bonus_3 : [0x663, 4],
         LocationName.swoopy_salvo_dk      : [0x663, 5],
     }
+    if world.kongsanity[player]:
+        swoopy_salvo_region_locations[LocationName.swoopy_salvo_kong] = []
     swoopy_salvo_region = create_region(world, player, active_locations, LocationName.swoopy_salvo_region,
                                         swoopy_salvo_region_locations, None)
 
@@ -503,9 +581,7 @@ def create_regions(world, player: int, active_locations):
 
     sky_high_secret_region_locations = {}
     if False:#world.include_trade_sequence[player]:
-        sky_high_secret_region_locations.update({
-            LocationName.sky_high_secret: [0x64B, 1],
-        })
+        sky_high_secret_region_locations[LocationName.sky_high_secret] = [0x64B, 1]
     sky_high_secret_region = create_region(world, player, active_locations, LocationName.sky_high_secret_region,
                                            sky_high_secret_region_locations, None)
 
@@ -517,9 +593,7 @@ def create_regions(world, player: int, active_locations):
 
     cifftop_cache_region_locations = {}
     if False:#world.include_trade_sequence[player]:
-        cifftop_cache_region_locations.update({
-            LocationName.cifftop_cache: [0x64D, 1],
-        })
+        cifftop_cache_region_locations[LocationName.cifftop_cache] = [0x64D, 1]
     cifftop_cache_region = create_region(world, player, active_locations, LocationName.cifftop_cache_region,
                                          cifftop_cache_region_locations, None)
 
@@ -622,29 +696,19 @@ def create_regions(world, player: int, active_locations):
             LocationName.bazaars_general_store_2: [0x615, 3, True],
         })
 
-        bramble_region_locations.update({
-            LocationName.brambles_bungalow: [0x619, 2],
-        })
+        bramble_region_locations[LocationName.brambles_bungalow] = [0x619, 2]
 
         #flower_spot_region_locations.update({
         #    LocationName.flower_spot: [0x615, 3, True],
         #})
 
-        barter_region_locations.update({
-            LocationName.barters_swap_shop: [0x61B, 3],
-        })
+        barter_region_locations[LocationName.barters_swap_shop] = [0x61B, 3]
 
-        barnacle_region_locations.update({
-            LocationName.barnacles_island: [0x61D, 2],
-        })
+        barnacle_region_locations[LocationName.barnacles_island] = [0x61D, 2]
 
-        blue_region_locations.update({
-            LocationName.blues_beach_hut: [0x621, 4],
-        })
+        blue_region_locations[LocationName.blues_beach_hut] = [0x621, 4]
 
-        blizzard_region_locations.update({
-            LocationName.blizzards_basecamp: [0x625, 4, True],
-        })
+        blizzard_region_locations[LocationName.blizzards_basecamp] = [0x625, 4, True]
 
     bazaar_region = create_region(world, player, active_locations, LocationName.bazaar_region,
                                   bazaar_region_locations, None)
@@ -817,7 +881,6 @@ def connect_regions(world, player, level_list):
         level_list[32],
         level_list[33],
         level_list[34],
-        LocationName.kastle_kaos_region,
         LocationName.sewer_stockpile_region,
     ]
 
@@ -835,10 +898,16 @@ def connect_regions(world, player, level_list):
 
     for i in range(0, len(krematoa_levels)):
         connect(world, player, names, LocationName.krematoa_region, krematoa_levels[i],
-                lambda state: (state.has(ItemName.bonus_coin, player, world.krematoa_bonus_coin_cost[player].value * (i+1))))
-                
-    connect(world, player, names, LocationName.krematoa_region, LocationName.knautilus_region,
-            lambda state: (state.has(ItemName.krematoa_cog, player, 5)))
+                lambda state, i=i: (state.has(ItemName.bonus_coin, player, world.krematoa_bonus_coin_cost[player].value * (i+1))))
+
+    if world.goal[player] == "knautilus":
+        connect(world, player, names, LocationName.kaos_kore_region, LocationName.knautilus_region)
+        connect(world, player, names, LocationName.krematoa_region, LocationName.kastle_kaos_region,
+                lambda state: (state.has(ItemName.krematoa_cog, player, 5)))
+    else:
+        connect(world, player, names, LocationName.kaos_kore_region, LocationName.kastle_kaos_region)
+        connect(world, player, names, LocationName.krematoa_region, LocationName.knautilus_region,
+                lambda state: (state.has(ItemName.krematoa_cog, player, 5)))
 
 
 def create_region(world: MultiWorld, player: int, active_locations, name: str, locations=None, exits=None):

worlds/dkc3/Rom.py

@@ -11,187 +11,270 @@ import os
 import math
 
 
+level_unlock_map = {
+    0x657: [0x65A],
+    0x65A: [0x680, 0x639, 0x659],
+    0x659: [0x65D],
+    0x65D: [0x65C],
+    0x65C: [0x688, 0x64F],
+
+    0x662: [0x681, 0x664],
+    0x664: [0x65B],
+    0x65B: [0x689, 0x661],
+    0x661: [0x63A, 0x666],
+    0x666: [0x650, 0x649],
+
+    0x667: [0x66A],
+    0x66A: [0x682, 0x658],
+    0x658: [0x68A, 0x66B],
+    0x66B: [0x668],
+    0x668: [0x651],
+
+    0x66D: [0x63C, 0x672],
+    0x672: [0x68B, 0x660],
+    0x660: [0x683, 0x66E],
+    0x66E: [0x670],
+    0x670: [0x652],
+
+    0x673: [0x684, 0x65F],
+    0x65F: [0x66C],
+    0x66C: [0x66F],
+    0x66F: [0x65E],
+    0x65E: [0x63D, 0x653, 0x68C, 0x64C],
+
+    0x676: [0x63E, 0x674, 0x685],
+    0x674: [0x63F, 0x669],
+    0x669: [0x677],
+    0x677: [0x68D, 0x675],
+    0x675: [0x654],
+
+    0x67A: [0x640, 0x678],
+    0x678: [0x665],
+    0x665: [0x686, 0x679],
+    0x679: [0x68E, 0x671],
+
+    0x67B: [0x67C],
+    0x67C: [0x67D],
+    0x67D: [0x663],
+    0x663: [0x67E],
+}
+
 location_rom_data = {
     0xDC3000: [0x657, 1], # Lakeside Limbo
     0xDC3001: [0x657, 2],
     0xDC3002: [0x657, 3],
     0xDC3003: [0x657, 5],
+    0xDC3100: [0x657, 7],
 
     0xDC3004: [0x65A, 1], # Doorstop Dash
     0xDC3005: [0x65A, 2],
     0xDC3006: [0x65A, 3],
     0xDC3007: [0x65A, 5],
+    0xDC3104: [0x65A, 7],
 
     0xDC3008: [0x659, 1], # Tidal Trouble
     0xDC3009: [0x659, 2],
     0xDC300A: [0x659, 3],
     0xDC300B: [0x659, 5],
+    0xDC3108: [0x659, 7],
 
     0xDC300C: [0x65D, 1], # Skidda's Row
     0xDC300D: [0x65D, 2],
     0xDC300E: [0x65D, 3],
     0xDC300F: [0x65D, 5],
+    0xDC310C: [0x65D, 7],
 
     0xDC3010: [0x65C, 1], # Murky Mill
     0xDC3011: [0x65C, 2],
     0xDC3012: [0x65C, 3],
     0xDC3013: [0x65C, 5],
+    0xDC3110: [0x65C, 7],
 
 
     0xDC3014: [0x662, 1], # Barrel Shield Bust-Up
     0xDC3015: [0x662, 2],
     0xDC3016: [0x662, 3],
     0xDC3017: [0x662, 5],
+    0xDC3114: [0x662, 7],
 
     0xDC3018: [0x664, 1], # Riverside Race
     0xDC3019: [0x664, 2],
     0xDC301A: [0x664, 3],
     0xDC301B: [0x664, 5],
+    0xDC3118: [0x664, 7],
 
     0xDC301C: [0x65B, 1], # Squeals on Wheels
     0xDC301D: [0x65B, 2],
     0xDC301E: [0x65B, 3],
     0xDC301F: [0x65B, 5],
+    0xDC311C: [0x65B, 7],
 
     0xDC3020: [0x661, 1], # Springin' Spiders
     0xDC3021: [0x661, 2],
     0xDC3022: [0x661, 3],
     0xDC3023: [0x661, 5],
+    0xDC3120: [0x661, 7],
 
     0xDC3024: [0x666, 1], # Bobbing Barrel Brawl
     0xDC3025: [0x666, 2],
     0xDC3026: [0x666, 3],
     0xDC3027: [0x666, 5],
+    0xDC3124: [0x666, 7],
 
 
     0xDC3028: [0x667, 1], # Bazza's Blockade
     0xDC3029: [0x667, 2],
     0xDC302A: [0x667, 3],
     0xDC302B: [0x667, 5],
+    0xDC3128: [0x667, 7],
 
     0xDC302C: [0x66A, 1], # Rocket Barrel Ride
     0xDC302D: [0x66A, 2],
     0xDC302E: [0x66A, 3],
     0xDC302F: [0x66A, 5],
+    0xDC312C: [0x66A, 7],
 
     0xDC3030: [0x658, 1], # Kreeping Klasps
     0xDC3031: [0x658, 2],
     0xDC3032: [0x658, 3],
     0xDC3033: [0x658, 5],
+    0xDC3130: [0x658, 7],
 
     0xDC3034: [0x66B, 1], # Tracker Barrel Trek
     0xDC3035: [0x66B, 2],
     0xDC3036: [0x66B, 3],
     0xDC3037: [0x66B, 5],
+    0xDC3134: [0x66B, 7],
 
     0xDC3038: [0x668, 1], # Fish Food Frenzy
     0xDC3039: [0x668, 2],
     0xDC303A: [0x668, 3],
     0xDC303B: [0x668, 5],
+    0xDC3138: [0x668, 7],
 
 
     0xDC303C: [0x66D, 1], # Fire-ball Frenzy
     0xDC303D: [0x66D, 2],
     0xDC303E: [0x66D, 3],
     0xDC303F: [0x66D, 5],
+    0xDC313C: [0x66D, 7],
 
     0xDC3040: [0x672, 1], # Demolition Drainpipe
     0xDC3041: [0x672, 2],
     0xDC3042: [0x672, 3],
     0xDC3043: [0x672, 5],
+    0xDC3140: [0x672, 7],
 
     0xDC3044: [0x660, 1], # Ripsaw Rage
     0xDC3045: [0x660, 2],
     0xDC3046: [0x660, 3],
     0xDC3047: [0x660, 5],
+    0xDC3144: [0x660, 7],
 
     0xDC3048: [0x66E, 1], # Blazing Bazukas
     0xDC3049: [0x66E, 2],
     0xDC304A: [0x66E, 3],
     0xDC304B: [0x66E, 5],
+    0xDC3148: [0x66E, 7],
 
     0xDC304C: [0x670, 1], # Low-G Labyrinth
     0xDC304D: [0x670, 2],
     0xDC304E: [0x670, 3],
     0xDC304F: [0x670, 5],
+    0xDC314C: [0x670, 7],
 
 
     0xDC3050: [0x673, 1], # Krevice Kreepers
     0xDC3051: [0x673, 2],
     0xDC3052: [0x673, 3],
     0xDC3053: [0x673, 5],
+    0xDC3150: [0x673, 7],
 
     0xDC3054: [0x65F, 1], # Tearaway Toboggan
     0xDC3055: [0x65F, 2],
     0xDC3056: [0x65F, 3],
     0xDC3057: [0x65F, 5],
+    0xDC3154: [0x65F, 7],
 
     0xDC3058: [0x66C, 1], # Barrel Drop Bounce
     0xDC3059: [0x66C, 2],
     0xDC305A: [0x66C, 3],
     0xDC305B: [0x66C, 5],
+    0xDC3158: [0x66C, 7],
 
     0xDC305C: [0x66F, 1], # Krack-Shot Kroc
     0xDC305D: [0x66F, 2],
     0xDC305E: [0x66F, 3],
     0xDC305F: [0x66F, 5],
+    0xDC315C: [0x66F, 7],
 
     0xDC3060: [0x65E, 1], # Lemguin Lunge
     0xDC3061: [0x65E, 2],
     0xDC3062: [0x65E, 3],
     0xDC3063: [0x65E, 5],
+    0xDC3160: [0x65E, 7],
 
 
     0xDC3064: [0x676, 1], # Buzzer Barrage
     0xDC3065: [0x676, 2],
     0xDC3066: [0x676, 3],
     0xDC3067: [0x676, 5],
+    0xDC3164: [0x676, 7],
 
     0xDC3068: [0x674, 1], # Kong-Fused Cliffs
     0xDC3069: [0x674, 2],
     0xDC306A: [0x674, 3],
     0xDC306B: [0x674, 5],
+    0xDC3168: [0x674, 7],
 
     0xDC306C: [0x669, 1], # Floodlit Fish
     0xDC306D: [0x669, 2],
     0xDC306E: [0x669, 3],
     0xDC306F: [0x669, 5],
+    0xDC316C: [0x669, 7],
 
     0xDC3070: [0x677, 1], # Pothole Panic
     0xDC3071: [0x677, 2],
     0xDC3072: [0x677, 3],
     0xDC3073: [0x677, 5],
+    0xDC3170: [0x677, 7],
 
     0xDC3074: [0x675, 1], # Ropey Rumpus
     0xDC3075: [0x675, 2],
     0xDC3076: [0x675, 3],
     0xDC3077: [0x675, 5],
+    0xDC3174: [0x675, 7],
 
 
     0xDC3078: [0x67A, 1], # Konveyor Rope Klash
     0xDC3079: [0x67A, 2],
     0xDC307A: [0x67A, 3],
     0xDC307B: [0x67A, 5],
+    0xDC3178: [0x67A, 7],
 
     0xDC307C: [0x678, 1], # Creepy Caverns
     0xDC307D: [0x678, 2],
     0xDC307E: [0x678, 3],
     0xDC307F: [0x678, 5],
+    0xDC317C: [0x678, 7],
 
     0xDC3080: [0x665, 1], # Lightning Lookout
     0xDC3081: [0x665, 2],
     0xDC3082: [0x665, 3],
     0xDC3083: [0x665, 5],
+    0xDC3180: [0x665, 7],
 
     0xDC3084: [0x679, 1], # Koindozer Klamber
     0xDC3085: [0x679, 2],
     0xDC3086: [0x679, 3],
     0xDC3087: [0x679, 5],
+    0xDC3184: [0x679, 7],
 
     0xDC3088: [0x671, 1], # Poisonous Pipeline
     0xDC3089: [0x671, 2],
     0xDC308A: [0x671, 3],
     0xDC308B: [0x671, 5],
+    0xDC3188: [0x671, 7],
 
 
     0xDC308C: [0x67B, 1], # Stampede Sprint
@@ -199,23 +282,27 @@ location_rom_data = {
     0xDC308E: [0x67B, 3],
     0xDC308F: [0x67B, 4],
     0xDC3090: [0x67B, 5],
+    0xDC318C: [0x67B, 7],
 
     0xDC3091: [0x67C, 1], # Criss Kross Cliffs
     0xDC3092: [0x67C, 2],
     0xDC3093: [0x67C, 3],
     0xDC3094: [0x67C, 5],
+    0xDC3191: [0x67C, 7],
 
     0xDC3095: [0x67D, 1], # Tyrant Twin Tussle
     0xDC3096: [0x67D, 2],
     0xDC3097: [0x67D, 3],
     0xDC3098: [0x67D, 4],
     0xDC3099: [0x67D, 5],
+    0xDC3195: [0x67D, 7],
 
     0xDC309A: [0x663, 1], # Swoopy Salvo
     0xDC309B: [0x663, 2],
     0xDC309C: [0x663, 3],
     0xDC309D: [0x663, 4],
     0xDC309E: [0x663, 5],
+    0xDC319A: [0x663, 7],
 
     0xDC309F: [0x67E, 1], # Rocket Rush
     0xDC30A0: [0x67E, 5],
@@ -243,7 +330,7 @@ location_rom_data = {
     #0xDC30B4: [0x64D, 1], # Disabled until Trade Sequence
     0xDC30B5: [0x64E, 1],
 
-    0xDC30B6: [0x5FD, 4], # Banana Bird Mother
+    0xDC30B6: [0x5FE, 4], # Banana Bird Mother
 
     # DKC3_TODO: Disabled until Trade Sequence
     #0xDC30B7: [0x615, 2, True],
@@ -256,6 +343,18 @@ location_rom_data = {
     #0xDC30BE: [0x625, 4, True],
 }
 
+boss_location_ids = [
+    0xDC30A1,
+    0xDC30A2,
+    0xDC30A3,
+    0xDC30A4,
+    0xDC30A5,
+    0xDC30A6,
+    0xDC30A7,
+    0xDC30A8,
+    0xDC30B6,
+]
+
 
 item_rom_data = {
     0xDC3001: [0x5D5], # 1-Up Balloon
@@ -400,10 +499,13 @@ def patch_rom(world, rom, player, active_level_list):
     rom.write_byte(0x3484DE, 0xEA)
     rom.write_byte(0x348528, 0x80) # Prevent Single-Ski Lock
 
-
     # Make Swanky free
     rom.write_byte(0x348C48, 0x00)
 
+    rom.write_bytes(0x34AB70, bytearray([0xEA, 0xEA]))
+    rom.write_bytes(0x34ABF7, bytearray([0xEA, 0xEA]))
+    rom.write_bytes(0x34ACD0, bytearray([0xEA, 0xEA]))
+
     # Banana Bird Costs
     if world.goal[player] == "banana_bird_hunt":
         banana_bird_cost = math.floor(world.number_of_banana_birds[player] * world.percentage_of_banana_birds[player] / 100.0)
@@ -462,6 +564,25 @@ def patch_rom(world, rom, player, active_level_list):
     rom.write_byte(0x9130, world.starting_life_count[player].value)
     rom.write_byte(0x913B, world.starting_life_count[player].value)
 
+    # Cheat options
+    cheat_bytes = [0x00, 0x00]
+
+    if world.merry[player]:
+        cheat_bytes[0] |= 0x01
+
+    if world.autosave[player]:
+        cheat_bytes[0] |= 0x02
+
+    if world.difficulty[player] == "tufst":
+        cheat_bytes[0] |= 0x80
+        cheat_bytes[1] |= 0x80
+    elif world.difficulty[player] == "hardr":
+        cheat_bytes[0] |= 0x00
+        cheat_bytes[1] |= 0x00
+    elif world.difficulty[player] == "norml":
+        cheat_bytes[1] |= 0x40
+
+    rom.write_bytes(0x8303, bytearray(cheat_bytes))
 
     # Handle Level Shuffle Here
     if world.level_shuffle[player]:
@@ -469,6 +590,9 @@ def patch_rom(world, rom, player, active_level_list):
             rom.write_byte(level_dict[level_list[i]].nameIDAddress, level_dict[active_level_list[i]].nameID)
             rom.write_byte(level_dict[level_list[i]].levelIDAddress, level_dict[active_level_list[i]].levelID)
 
+            rom.write_byte(0x3FF800 + level_dict[active_level_list[i]].levelID, level_dict[level_list[i]].levelID)
+            rom.write_byte(0x3FF860 + level_dict[level_list[i]].levelID, level_dict[active_level_list[i]].levelID)
+
         # First levels of each world
         rom.write_byte(0x34BC3E, (0x32 + level_dict[active_level_list[0]].levelID))
         rom.write_byte(0x34BC47, (0x32 + level_dict[active_level_list[5]].levelID))
@@ -495,6 +619,52 @@ def patch_rom(world, rom, player, active_level_list):
 
         rom.write_byte(0x32F339, 0x55)
 
+    # Handle KONGsanity Here
+    if world.kongsanity[player]:
+        # Arich's Hoard KONGsanity fix
+        rom.write_bytes(0x34BA8C, bytearray([0xEA, 0xEA]))
+
+        # Don't hide the level flag if the 0x80 bit is set
+        rom.write_bytes(0x34CE92, bytearray([0x80]))
+
+        # Use the `!` next to level name for indicating KONG letters
+        rom.write_bytes(0x34B8F0, bytearray([0x80]))
+        rom.write_bytes(0x34B8F3, bytearray([0x80]))
+
+        # Hijack to code to set the 0x80 flag for the level when you complete KONG
+        rom.write_bytes(0x3BCD4B, bytearray([0x22, 0x80, 0xFA, 0XB8])) # JSL $B8FA80
+
+        rom.write_bytes(0x38FA80, bytearray([0xDA]))             # PHX
+        rom.write_bytes(0x38FA81, bytearray([0x48]))             # PHA
+        rom.write_bytes(0x38FA82, bytearray([0x08]))             # PHP
+        rom.write_bytes(0x38FA83, bytearray([0xE2, 0x20]))       # SEP #20
+        rom.write_bytes(0x38FA85, bytearray([0x48]))             # PHA
+        rom.write_bytes(0x38FA86, bytearray([0x18]))             # CLC
+        rom.write_bytes(0x38FA87, bytearray([0x6D, 0xD3, 0x18])) # ADC $18D3
+        rom.write_bytes(0x38FA8A, bytearray([0x8D, 0xD3, 0x18])) # STA $18D3
+        rom.write_bytes(0x38FA8D, bytearray([0x68]))             # PLA
+        rom.write_bytes(0x38FA8E, bytearray([0xC2, 0x20]))       # REP 20
+        rom.write_bytes(0x38FA90, bytearray([0X18]))             # CLC
+        rom.write_bytes(0x38FA91, bytearray([0x6D, 0xD5, 0x05])) # ADC $05D5
+        rom.write_bytes(0x38FA94, bytearray([0x8D, 0xD5, 0x05])) # STA $05D5
+        rom.write_bytes(0x38FA97, bytearray([0xAE, 0xB9, 0x05])) # LDX $05B9
+        rom.write_bytes(0x38FA9A, bytearray([0xBD, 0x32, 0x06])) # LDA $0632, X
+        rom.write_bytes(0x38FA9D, bytearray([0x09, 0x80, 0x00])) # ORA #8000
+        rom.write_bytes(0x38FAA0, bytearray([0x9D, 0x32, 0x06])) # STA $0632, X
+        rom.write_bytes(0x38FAA3, bytearray([0xAD, 0xD5, 0x18])) # LDA $18D5
+        rom.write_bytes(0x38FAA6, bytearray([0xD0, 0x03]))       # BNE $80EA
+        rom.write_bytes(0x38FAA8, bytearray([0x9C, 0xD9, 0x18])) # STZ $18D9
+        rom.write_bytes(0x38FAAB, bytearray([0xA9, 0x78, 0x00])) # LDA #0078
+        rom.write_bytes(0x38FAAE, bytearray([0x8D, 0xD5, 0x18])) # STA $18D5
+        rom.write_bytes(0x38FAB1, bytearray([0x28]))             # PLP
+        rom.write_bytes(0x38FAB2, bytearray([0x68]))             # PLA
+        rom.write_bytes(0x38FAB3, bytearray([0xFA]))             # PLX
+        rom.write_bytes(0x38FAB4, bytearray([0x6B]))             # RTL
+    # End Handle KONGsanity
+
+    # Handle Credits
+    rom.write_bytes(0x32A5DF, bytearray([0x41, 0x52, 0x43, 0x48, 0x49, 0x50, 0x45, 0x4C, 0x41, 0x47, 0x4F, 0x20, 0x4D, 0x4F, 0xC4])) # "ARCHIPELAGO MOD"
+    rom.write_bytes(0x32A5EE, bytearray([0x00, 0x03, 0x50, 0x4F, 0x52, 0x59, 0x47, 0x4F, 0x4E, 0xC5])) # "PORYGONE"
 
     from Main import __version__
     rom.name = bytearray(f'D3{__version__.replace(".", "")[0:3]}_{player}_{world.seed:11}\0', 'utf8')[:21]
@@ -516,6 +686,17 @@ def patch_rom(world, rom, player, active_level_list):
     rom.write_byte(0x32DD63, 0xEA)
     rom.write_byte(0x32DD64, 0xEA)
 
+    # Don't grant Banana Birds at Bears
+    rom.write_byte(0x3492DB, 0xEA)
+    rom.write_byte(0x3492DC, 0xEA)
+    rom.write_byte(0x3492DD, 0xEA)
+    rom.write_byte(0x3493F4, 0xEA)
+    rom.write_byte(0x3493F5, 0xEA)
+    rom.write_byte(0x3493F6, 0xEA)
+
+    # Don't grant present at Blizzard
+    rom.write_byte(0x8454, 0x00)
+
     # Don't grant Patch and Skis from their bosses
     rom.write_byte(0x3F3762, 0x00)
     rom.write_byte(0x3F377B, 0x00)

worlds/dkc3/__init__.py

@@ -4,7 +4,7 @@ import math
 import threading
 
 from BaseClasses import Item, MultiWorld, Tutorial, ItemClassification
-from .Items import DKC3Item, ItemData, item_table, inventory_table
+from .Items import DKC3Item, ItemData, item_table, inventory_table, junk_table
 from .Locations import DKC3Location, all_locations, setup_locations
 from .Options import dkc3_options
 from .Regions import create_regions, connect_regions
@@ -40,7 +40,7 @@ class DKC3World(World):
     game: str = "Donkey Kong Country 3"
     option_definitions = dkc3_options
     topology_present = False
-    data_version = 1
+    data_version = 2
     #hint_blacklist = {LocationName.rocket_rush_flag}
 
     item_name_to_id = {name: data.code for name, data in item_table.items()}
@@ -99,10 +99,13 @@ class DKC3World(World):
 
         # Bosses
         total_required_locations += number_of_bosses
-        
+
         # Secret Caves
         total_required_locations += 13
 
+        if self.world.kongsanity[self.player]:
+            total_required_locations += 39
+
         ## Brothers Bear
         if False:#self.world.include_trade_sequence[self.player]:
             total_required_locations += 10
@@ -118,7 +121,11 @@ class DKC3World(World):
 
         total_junk_count = total_required_locations - len(itempool)
 
-        itempool += [self.create_item(ItemName.bear_coin)] * total_junk_count
+        junk_pool = []
+        for item_name in self.world.random.choices(list(junk_table.keys()), k=total_junk_count):
+            junk_pool += [self.create_item(item_name)]
+
+        itempool += junk_pool
 
         self.active_level_list = level_list.copy()
 

worlds/factorio/Mod.py

@@ -14,7 +14,7 @@ import Patch
 from . import Options
 
 from .Technologies import tech_table, recipes, free_sample_exclusions, progressive_technology_table, \
-    base_tech_table, tech_to_progressive_lookup, fluids
+    base_tech_table, tech_to_progressive_lookup, fluids, mods, tech_table, factorio_base_id
 
 template_env: Optional[jinja2.Environment] = None
 
@@ -34,7 +34,9 @@ base_info = {
     "factorio_version": "1.1",
     "dependencies": [
         "base >= 1.1.0",
-        "? science-not-invited"
+        "? science-not-invited",
+        "? factory-levels",
+        "! archipelago-extractor"
     ]
 }
 
@@ -107,7 +109,7 @@ def generate_mod(world, output_directory: str):
     random = multiworld.slot_seeds[player]
 
     def flop_random(low, high, base=None):
-        """Guarentees 50% below base and 50% above base, uniform distribution in each direction."""
+        """Guarantees 50% below base and 50% above base, uniform distribution in each direction."""
         if base:
             distance = random.random()
             if random.randint(0, 1):
@@ -116,6 +118,10 @@ def generate_mod(world, output_directory: str):
                 return base - (base - low) * distance
         return random.uniform(low, high)
 
+    all_items = tech_table.copy()
+    all_items["Attack Trap"] = factorio_base_id - 1
+    all_items["Evolution Trap"] = factorio_base_id - 2
+
     template_data = {
         "locations": locations, "player_names": multiworld.player_name, "tech_table": tech_table,
         "base_tech_table": base_tech_table, "tech_to_progressive_lookup": tech_to_progressive_lookup,
@@ -134,11 +140,13 @@ def generate_mod(world, output_directory: str):
         "free_sample_blacklist": {item: 1 for item in free_sample_exclusions},
         "progressive_technology_table": {tech.name: tech.progressive for tech in
                                          progressive_technology_table.values()},
+        "item_id_to_name": {f"{item_id}": item_name for item_name, item_id in all_items.items()},
         "custom_recipes": world.custom_recipes,
         "max_science_pack": multiworld.max_science_pack[player].value,
         "liquids": fluids,
         "goal": multiworld.goal[player].value,
-        "energy_link": multiworld.energy_link[player].value
+        "energy_link": multiworld.energy_link[player].value,
+        "custom_data_package": 1 if mods else 0
     }
 
     for factorio_option in Options.factorio_options:
@@ -191,6 +199,8 @@ def generate_mod(world, output_directory: str):
         f.write(locale_content)
     info = base_info.copy()
     info["name"] = mod_name
+    for mod in mods.values():
+        info["dependencies"].append(f"{mod.name} >= {mod.version}")
     with open(os.path.join(mod_dir, "info.json"), "wt") as f:
         json.dump(info, f, indent=4)
 

worlds/factorio/Options.py

@@ -137,8 +137,6 @@ class Progressive(Choice):
     option_off = 0
     option_grouped_random = 1
     option_on = 2
-    alias_false = 0
-    alias_true = 2
     default = 2
 
     def want_progressives(self, random):

worlds/factorio/Technologies.py

@@ -4,6 +4,7 @@ import json
 import logging
 import os
 import string
+from sys import getrecursionlimit
 from collections import Counter
 from concurrent.futures import ThreadPoolExecutor
 from typing import Dict, Set, FrozenSet, Tuple, Union, List, Any
@@ -22,13 +23,14 @@ def load_json_data(data_name: str) -> Union[List[str], Dict[str, Any]]:
     import pkgutil
     return json.loads(pkgutil.get_data(__name__, "data/" + data_name + ".json").decode())
 
-
+# TODO: Make use of the lab information. (it has info on the science packs)
 techs_future = pool.submit(load_json_data, "techs")
 recipes_future = pool.submit(load_json_data, "recipes")
 resources_future = pool.submit(load_json_data, "resources")
 machines_future = pool.submit(load_json_data, "machines")
 fluids_future = pool.submit(load_json_data, "fluids")
 items_future = pool.submit(load_json_data, "items")
+mods_future = pool.submit(load_json_data, "mods")
 
 tech_table: Dict[str, int] = {}
 technology_table: Dict[str, Technology] = {}
@@ -94,6 +96,8 @@ class CustomTechnology(Technology):
 
     def __init__(self, origin: Technology, world, allowed_packs: Set[str], player: int):
         ingredients = origin.ingredients & allowed_packs
+        if origin.ingredients and not ingredients:
+            logging.warning(f"Technology {origin.name} has no vanilla science packs. Custom science packs are not supported.")
         military_allowed = "military-science-pack" in allowed_packs \
                            and ((ingredients & {"chemical-science-pack", "production-science-pack", "utility-science-pack"})
                                 or origin.name == "rocket-silo")
@@ -103,7 +107,8 @@ class CustomTechnology(Technology):
                 ingredients.add("military-science-pack")
             ingredients = list(ingredients)
             ingredients.sort()  # deterministic sample
-            ingredients = world.random.sample(ingredients, world.random.randint(1, len(ingredients)))
+            if ingredients:
+                ingredients = world.random.sample(ingredients, world.random.randint(1, len(ingredients)))
         elif origin.name == "rocket-silo" and military_allowed:
             ingredients.add("military-science-pack")
         super(CustomTechnology, self).__init__(origin.name, ingredients, origin.factorio_id)
@@ -115,13 +120,19 @@ class Recipe(FactorioElement):
     ingredients: Dict[str, int]
     products: Dict[str, int]
     energy: float
+    mining: bool
+    burning: bool
+    unlocked_at_start: bool
 
-    def __init__(self, name: str, category: str, ingredients: Dict[str, int], products: Dict[str, int], energy: float):
+    def __init__(self, name: str, category: str, ingredients: Dict[str, int], products: Dict[str, int], energy: float, mining: bool = False, unlocked_at_start: bool = False, burning: bool = False):
         self.name = name
         self.category = category
         self.ingredients = ingredients
         self.products = products
         self.energy = energy
+        self.mining = mining
+        self.burning = burning
+        self.unlocked_at_start = unlocked_at_start
 
     def __repr__(self):
         return f"{self.__class__.__name__}({self.name})"
@@ -147,28 +158,56 @@ class Recipe(FactorioElement):
     @property
     def rel_cost(self) -> float:
         ingredients = sum(self.ingredients.values())
-        return min(ingredients / amount for product, amount in self.products.items())
+        if all(amount == 0 for amount in self.products.values()):
+            return float('inf')
+        return min(ingredients / amount for product, amount in self.products.items() if amount > 0)
 
     @property
     def base_cost(self) -> Dict[str, int]:
         ingredients = Counter()
         for ingredient, cost in self.ingredients.items():
             if ingredient in all_product_sources:
+                recipe_counters: Dict[str, (Recipe, Counter)] = {}
                 for recipe in all_product_sources[ingredient]:
+                    recipe_ingredients = Counter()
                     if recipe.ingredients:
-                        ingredients.update({name: amount * cost / recipe.products[ingredient] for name, amount in
+                        recipe_ingredients.update({name: amount * cost / recipe.products[ingredient] for name, amount in
                                             recipe.base_cost.items()})
                     else:
-                        ingredients[ingredient] += recipe.energy * cost / recipe.products[ingredient]
+                        recipe_ingredients[ingredient] += recipe.energy * cost / recipe.products[ingredient]
+                    recipe_counters[recipe.name] = (recipe, recipe_ingredients)
+                selected_recipe_ingredients = None
+                for recipe_name, (recipe, recipe_ingredients) in recipe_counters.items():
+                    if not selected_recipe_ingredients or (
+                            sum([rel_cost.get(name, high_cost_item) * value for name, value in recipe_ingredients.items()])
+                            < sum([rel_cost.get(name, high_cost_item) * value for name, value in selected_recipe_ingredients.items()])):
+                        selected_recipe_ingredients = recipe_ingredients
+                ingredients.update(selected_recipe_ingredients)
             else:
                 ingredients[ingredient] += cost
         return ingredients
 
+    recursion_loop = 0
+    max_recursion_loop = 0.85 * getrecursionlimit()
+
+    def detect_recursive_loop(self) -> bool:
+        Recipe.recursion_loop += 1
+        if Recipe.max_recursion_loop < Recipe.recursion_loop:
+            Recipe.recursion_loop = 0
+            return True
+        for ingredient in self.ingredients.keys():
+            if ingredient in all_product_sources:
+                for ingredient_recipe in all_product_sources[ingredient]:
+                    if ingredient_recipe.ingredients:
+                        if ingredient_recipe.detect_recursive_loop():
+                            return True
+        Recipe.recursion_loop -= 1
+        return False
+
     @property
     def total_energy(self) -> float:
         """Total required energy (crafting time) for single craft"""
-        # TODO: multiply mining energy by 2 since drill has 0.5 speed
-        total_energy = self.energy
+        total_energy = (self.energy / machines[self.crafting_machine].speed)
         for ingredient, cost in self.ingredients.items():
             if ingredient in all_product_sources:
                 selected_recipe_energy = float('inf')
@@ -182,10 +221,71 @@ class Recipe(FactorioElement):
 
 
 class Machine(FactorioElement):
-    def __init__(self, name, categories):
+    def __init__(self, name, categories, machine_type, speed, item_sources, input_fluids, output_fluids):
         self.name: str = name
         self.categories: set = categories
+        self.machine_type: str = machine_type
+        self.speed: float = speed
+        self.item_sources: set = item_sources
+        self.input_fluids: int = int(input_fluids)
+        self.output_fluids: int = int(output_fluids)
 
+class Lab(FactorioElement):
+    def __init__(self, name, inputs):
+        self.name: str = name
+        self.inputs: set = inputs
+
+
+class Mod(FactorioElement):
+    def __init__(self, name, version):
+        self.name: str = name
+        self.version: str = version
+
+
+class Item(FactorioElement):
+    def __init__(self, name, stack_size, stackable, place_result, burnt_result, fuel_value, fuel_category, rocket_launch_products):
+        self.name: str = name
+        self.stack_size: int = stack_size
+        self.stackable: bool = stackable
+        self.place_result: str = place_result
+        self.burnt_result: str = burnt_result
+        self.fuel_value: int = fuel_value
+        self.fuel_category: str = fuel_category
+        self.rocket_launch_products: Dict[str, int] = rocket_launch_products
+        self.product_sources: Set[Recipe] = set()
+
+class Fluid(FactorioElement):
+    def __init__(self, name, default_temperature, max_temperature, heat_capacity):
+        self.name: str = name
+        if max_temperature == "inf":
+            max_temperature = 2**64
+        self.default_temperature: int = default_temperature
+        self.max_temperature: int = max_temperature
+        self.heat_capacity = heat_capacity
+        self.product_sources: Set[Recipe] = set()
+
+
+items: Dict[str, Item] = {}
+for name, item_data in items_future.result().items():
+    item = Item(name,
+                item_data.get("stack_size"),
+                item_data.get("stackable"),
+                item_data.get("place_result", None),
+                item_data.get("burnt_result", None),
+                item_data.get("fuel_value", 0),
+                item_data.get("fuel_category", None),
+                item_data.get("rocket_launch_products", {}))
+    items[name] = item
+del items_future
+
+fluids: Dict[str, Fluid] = {}
+for name, fluid_data in fluids_future.result().items():
+    fluid = Fluid(name,
+                  fluid_data.get("default_temperature", 0),
+                  fluid_data.get("max_temperature", 0),
+                  fluid_data.get("heat_capacity", 1000))
+    fluids[name] = fluid
+del fluids_future
 
 recipe_sources: Dict[str, Set[str]] = {}  # recipe_name -> technology source
 
@@ -213,38 +313,149 @@ for resource_name, resource_data in resources_future.result().items():
         if "required_fluid" in resource_data else {},
         "products": {data["name"]: data["amount"] for data in resource_data["products"].values()},
         "energy": resource_data["mining_time"],
-        "category": resource_data["category"]
+        "category": resource_data["category"],
+        "mining": True,
+        "unlocked_at_start": True
     }
 del resources_future
 
+machines: Dict[str, Machine] = {}
+labs: Dict[str, Lab] = {}
+rel_cost = {}
+high_cost_item = 10000
+
+for name, prototype in machines_future.result().items():
+    machine_prototype = prototype.get("common", {}).get("type", None)
+    machine_item_sources = set(prototype.get("common", {}).get("placeable_by", {}))
+    for machine_type, machine_data in prototype.items():
+        if machine_type == "lab":
+            lab = Lab(name, machine_data.get("inputs", set()))
+            labs[name] = lab
+        if machine_type == "offshore-pump":
+            fluid = machine_data.get("fluid", None)
+            speed = machine_data.get("speed", None)
+            if not fluid or not speed:
+                continue
+            category = f"offshore-pumping-{fluid}-{speed}"
+            raw_recipes[category] = {
+                "ingredients": {},
+                "products": {fluid: (speed*60)},
+                "energy": 1,
+                "category": category,
+                "mining": True,
+                "unlocked_at_start": True
+            }
+            machine = Machine(name, {category}, machine_prototype, 1, machine_item_sources, 0, 1)
+            machines[name] = machine
+        if machine_type == "crafting":
+            categories = machine_data.get("categories", set())
+            if not categories:
+                continue
+            # TODO: Use speed / fluid_box info
+            speed = machine_data.get("speed", 1)
+            input_fluid_box = machine_data.get("input_fluid_box", 0)
+            output_fluid_box = machine_data.get("output_fluid_box", 0)
+            machine = Machine(name, set(categories), machine_prototype, speed, machine_item_sources, input_fluid_box, output_fluid_box)
+            machines[name] = machine
+        if machine_type == "mining":
+            categories = machine_data.get("categories", set())
+            if not categories:
+                continue
+            speed = machine_data.get("speed", 1)
+            input_fluid_box = machine_data.get("input_fluid_box", False)  # Can this machine mine resources with required fluids?
+            output_fluid_box = machine_data.get("output_fluid_box", False)  # Can this machine mine fluid resources?
+            machine = machines.setdefault(name, Machine(name, set(categories), machine_prototype, speed, machine_item_sources, input_fluid_box, output_fluid_box))
+            machine.categories |= set(categories)  # character has both crafting and basic-solid
+            machine.speed = (machine.speed + speed) / 2
+            machines[name] = machine
+        if machine_type == "boiler":
+            input_fluid = machine_data.get("input_fluid")
+            output_fluid = machine_data.get("output_fluid")
+            target_temperature = machine_data.get("target_temperature")
+            energy_usage = machine_data.get("energy_usage")
+            amount = energy_usage / (target_temperature - fluids[input_fluid].default_temperature) / fluids[input_fluid].heat_capacity
+            amount *= 60
+            amount = int(amount)
+            category = f"boiling-{amount}-{input_fluid}-to-{output_fluid}-at-{target_temperature}-degrees-centigrade"
+            raw_recipes[category] = {
+                "ingredients": {input_fluid: amount},
+                "products": {output_fluid: amount},
+                "energy": 1,
+                "category": category,
+                "mining": True,
+                "unlocked_at_start": True
+            }
+            machine = Machine(name, {category}, machine_prototype, 1, machine_item_sources, 1, 1)
+            machines[name] = machine
+        if machine_type == "fuel_burner":
+            categories = set(machine_data.get("categories"))
+            fuel_items = {name: item for name, item in items.items() if item.burnt_result and item.fuel_category in categories}
+            if not fuel_items:
+                continue
+            energy_usage = machine_data.get("energy_usage")
+            for item_name, item in fuel_items.items():
+                recipe_name = f"burning-{item_name}-for-{item.burnt_result}"
+                raw_recipes[recipe_name] = {
+                    "ingredients": {item_name: 1},
+                    "products": {item.burnt_result: 1},
+                    "energy": item.fuel_value,
+                    "category": item.fuel_category,
+                    "burning": True,
+                    "unlocked_at_start": True
+                }
+            machine = machines.get(name, Machine(name, categories, machine_prototype, energy_usage * 60, machine_item_sources, 0, 0))
+            machines[name] = machine
+
+
+        # TODO: set up machine/recipe pairs for burners in order to retrieve the burnt_result from items.
+        # TODO: set up machine/recipe pairs for retrieving rocket_launch_products from items.
+
+del machines_future
+
 for recipe_name, recipe_data in raw_recipes.items():
     # example:
     # "accumulator":{"ingredients":{"iron-plate":2,"battery":5},"products":{"accumulator":1},"category":"crafting"}
     # FIXME: add mining?
-    recipe = Recipe(recipe_name, recipe_data["category"], recipe_data["ingredients"],
-                    recipe_data["products"], recipe_data["energy"] if "energy" in recipe_data else 0)
+    recipe = Recipe(recipe_name,
+                    recipe_data["category"],
+                    recipe_data["ingredients"],
+                    recipe_data["products"],
+                    recipe_data.get("energy", 0),
+                    recipe_data.get("mining", False),
+                    recipe_data.get("unlocked_at_start", False),
+                    recipe_data.get("burning", False))
     recipes[recipe_name] = recipe
-    if set(recipe.products).isdisjoint(
-            # prevents loop recipes like uranium centrifuging
-            set(recipe.ingredients)) and ("empty-barrel" not in recipe.products or recipe.name == "empty-barrel") and \
-            not recipe_name.endswith("-reprocessing"):
-        for product_name in recipe.products:
+    if set(recipe.products).isdisjoint(set(recipe.ingredients)):
+        for product_name in [product_name for product_name, amount in recipe.products.items() if amount > 0]:
             all_product_sources.setdefault(product_name, set()).add(recipe)
+            if recipe.detect_recursive_loop():
+                # prevents loop recipes like uranium centrifuging and fluid unbarreling
+                all_product_sources.setdefault(product_name, set()).remove(recipe)
+                if not all_product_sources[product_name]:
+                    del (all_product_sources[product_name])
+            if product_name in items:
+                items[product_name].product_sources.add(recipe)
+            if product_name in fluids:
+                fluids[product_name].product_sources.add(recipe)
 
 
-machines: Dict[str, Machine] = {}
+machines["assembling-machine-1"].categories |= machines["assembling-machine-3"].categories  # mod enables this
+machines["assembling-machine-2"].categories |= machines["assembling-machine-3"].categories
+machines["rocket-silo"].input_fluids = 3
+# machines["character"].categories.add("basic-crafting")
+# charter only knows the categories of "crafting" and "basic-solid" by default.
 
-for name, categories in machines_future.result().items():
-    machine = Machine(name, set(categories))
-    machines[name] = machine
 
-# add electric mining drill as a crafting machine to resolve basic-solid (mining)
-machines["electric-mining-drill"] = Machine("electric-mining-drill", {"basic-solid"})
-machines["pumpjack"] = Machine("pumpjack", {"basic-fluid"})
-machines["assembling-machine-1"].categories.add("crafting-with-fluid")  # mod enables this
-machines["character"].categories.add("basic-crafting")  # somehow this is implied and not exported
+mods: Dict[str, Mod] = {}
+
+for name, version in mods_future.result().items():
+    if name in ["base", "archipelago-extractor"]:
+        continue
+    mod = Mod(name, version)
+    mods[name] = mod
+
+del mods_future
 
-del machines_future
 
 # build requirements graph for all technology ingredients
 
@@ -254,7 +465,10 @@ for technology in technology_table.values():
 
 
 def unlock_just_tech(recipe: Recipe, _done) -> Set[Technology]:
-    current_technologies = recipe.unlocking_technologies
+    if recipe.unlocked_at_start:
+        current_technologies = set()
+    else:
+        current_technologies = recipe.unlocking_technologies
     for ingredient_name in recipe.ingredients:
         current_technologies |= recursively_get_unlocking_technologies(ingredient_name, _done,
                                                                        unlock_func=unlock_just_tech)
@@ -262,7 +476,10 @@ def unlock_just_tech(recipe: Recipe, _done) -> Set[Technology]:
 
 
 def unlock(recipe: Recipe, _done) -> Set[Technology]:
-    current_technologies = recipe.unlocking_technologies
+    if recipe.unlocked_at_start:
+        current_technologies = set()
+    else:
+        current_technologies = recipe.unlocking_technologies
     for ingredient_name in recipe.ingredients:
         current_technologies |= recursively_get_unlocking_technologies(ingredient_name, _done, unlock_func=unlock)
     current_technologies |= required_category_technologies[recipe.category]
@@ -289,21 +506,46 @@ def recursively_get_unlocking_technologies(ingredient_name, _done=None, unlock_f
     return current_technologies
 
 
+for item_name, item in items.items():
+    if item.place_result and machines.get(item.place_result, None):
+        machines[item.place_result].item_sources |= {item_name}
+
+
 required_machine_technologies: Dict[str, FrozenSet[Technology]] = {}
-for ingredient_name in machines:
+for ingredient_name, machine in machines.items():
+    if ingredient_name == "character":
+        required_machine_technologies[ingredient_name] = frozenset()
+        continue
+    techs = recursively_get_unlocking_technologies(ingredient_name)
+    for item_name in machine.item_sources:
+        techs |= recursively_get_unlocking_technologies(item_name)
+    required_machine_technologies[ingredient_name] = frozenset(techs)
+
+for ingredient_name in labs:
     required_machine_technologies[ingredient_name] = frozenset(recursively_get_unlocking_technologies(ingredient_name))
 
 logical_machines = {}
 machine_tech_cost = {}
+
+for category in machines["character"].categories:
+    machine_tech_cost[category] = (10000, "character", machines["character"].speed)
+
 for machine in machines.values():
+    if machine.name == "character":
+        continue
     for category in machine.categories:
-        current_cost, current_machine = machine_tech_cost.get(category, (10000, "character"))
         machine_cost = len(required_machine_technologies[machine.name])
-        if machine_cost < current_cost:
-            machine_tech_cost[category] = machine_cost, machine.name
+        if machine.machine_type == "character" and not machine_cost:
+            machine_cost = 10000
+        if category in machine_tech_cost:
+            current_cost, current_machine, current_speed = machine_tech_cost.get(category)
+            if machine_cost < current_cost or (machine_cost == current_cost and machine.speed > current_speed):
+                machine_tech_cost[category] = machine_cost, machine.name, machine.speed
+        else:
+            machine_tech_cost[category] = machine_cost, machine.name, machine.speed
 
 machine_per_category: Dict[str: str] = {}
-for category, (cost, machine_name) in machine_tech_cost.items():
+for category, (cost, machine_name, speed) in machine_tech_cost.items():
     machine_per_category[category] = machine_name
 
 del machine_tech_cost
@@ -313,6 +555,10 @@ required_category_technologies: Dict[str, FrozenSet[FrozenSet[Technology]]] = {}
 for category_name, machine_name in machine_per_category.items():
     techs = set()
     techs |= recursively_get_unlocking_technologies(machine_name)
+    if category_name in machines["character"].categories and techs:
+        # Character crafting/mining categories always have no tech assigned.
+        techs = set()
+        machine_per_category[category_name] = "character"
     required_category_technologies[category_name] = frozenset(techs)
 
 required_technologies: Dict[str, FrozenSet[Technology]] = Utils.KeyedDefaultDict(lambda ingredient_name: frozenset(
@@ -333,7 +579,10 @@ def get_rocket_requirements(silo_recipe: Recipe, part_recipe: Recipe, satellite_
     return {tech.name for tech in techs}
 
 
-free_sample_exclusions: Set[str] = all_ingredient_names | {"rocket-part"}
+free_sample_exclusions: Set[str] = all_ingredient_names.copy()  # Rocket-silo crafting recipe results to be added here.
+for name, recipe in recipes.items():
+    if machines[recipe.crafting_machine].machine_type == "rocket-silo":
+        free_sample_exclusions |= set(recipe.products)
 
 # progressive technologies
 # auto-progressive
@@ -447,37 +696,49 @@ useless_technologies: Set[str] = {tech_name for tech_name in common_tech_table
 
 lookup_id_to_name: Dict[int, str] = {item_id: item_name for item_name, item_id in tech_table.items()}
 
-rel_cost = {
-    "wood": 10000,
-    "iron-ore": 1,
-    "copper-ore": 1,
-    "stone": 1,
-    "crude-oil": 0.5,
-    "water": 0.001,
-    "coal": 1,
-    "raw-fish": 1000,
-    "steam": 0.01,
-    "used-up-uranium-fuel-cell": 1000
-}
+for name, recipe in {name: recipe for name, recipe in recipes.items() if recipe.mining and not recipe.ingredients}.items():
+    machine = machines[machine_per_category[recipe.category]]
+    cost = recipe.energy / machine.speed
+    for product_name, amount in recipe.products.items():
+        rel_cost[product_name] = cost / amount
 
-exclusion_list: Set[str] = all_ingredient_names | {"rocket-part", "used-up-uranium-fuel-cell"}
-fluids: Set[str] = set(fluids_future.result())
-del fluids_future
+
+def get_estimated_difficulty(recipe: Recipe):
+    base_ingredients = recipe.base_cost
+    cost = 0
+
+    for ingredient_name, amount in base_ingredients.items():
+        cost += rel_cost.get(ingredient_name, high_cost_item) * amount
+    if recipe.burning:
+        for item in machines[recipe.crafting_machine].item_sources:
+            if items[item].product_sources:
+                cost += min([get_estimated_difficulty(recipe) for recipe in items[item].product_sources])
+            else:
+                cost += high_cost_item
+
+    # print(f"{recipe.name}: {cost} ({({ingredient_name: rel_cost.get(ingredient_name, high_cost_item) * amount for ingredient_name, amount in base_ingredients.items()})})")
+    return cost
+
+
+for name, recipe in {name: recipe for name, recipe in recipes.items() if recipe.mining and recipe.ingredients}.items():
+    machine = machines[machine_per_category[recipe.category]]
+    cost = (recipe.energy / machine.speed) + get_estimated_difficulty(recipe)
+    for product_name, amount in recipe.products.items():
+        rel_cost[product_name] = cost / amount
+
+exclusion_list: Set[str] = free_sample_exclusions.copy()  # Also exclude the burnt results.
 
 
 @Utils.cache_argsless
 def get_science_pack_pools() -> Dict[str, Set[str]]:
-    def get_estimated_difficulty(recipe: Recipe):
-        base_ingredients = recipe.base_cost
-        cost = 0
-
-        for ingredient_name, amount in base_ingredients.items():
-            cost += rel_cost.get(ingredient_name, 1) * amount
-        return cost
-
     science_pack_pools: Dict[str, Set[str]] = {}
     already_taken = exclusion_list.copy()
-    current_difficulty = 5
+    unlocked_recipes = {name: recipe for name, recipe in recipes.items()
+                        if recipe.unlocked_at_start
+                        and not recipe.recursive_unlocking_technologies
+                        and get_estimated_difficulty(recipe) < high_cost_item}  # wood in recipe is expensive.
+    average_starting_difficulty = sum([get_estimated_difficulty(recipe) for name, recipe in unlocked_recipes.items()]) / len(unlocked_recipes)
+    current_difficulty = min(average_starting_difficulty, 8)
     for science_pack in Options.MaxSciencePack.get_ordered_science_packs():
         current = science_pack_pools[science_pack] = set()
         for name, recipe in recipes.items():
@@ -487,9 +748,7 @@ def get_science_pack_pools() -> Dict[str, Set[str]]:
 
         if science_pack == "automation-science-pack":
             # Can't handcraft automation science if fluids end up in its recipe, making the seed impossible.
-            current -= fluids
-        elif science_pack == "logistic-science-pack":
-            current |= {"steam"}
+            current -= set(fluids)
 
         current -= already_taken
         already_taken |= current
@@ -498,10 +757,9 @@ def get_science_pack_pools() -> Dict[str, Set[str]]:
     return science_pack_pools
 
 
-item_stack_sizes: Dict[str, int] = items_future.result()
-non_stacking_items: Set[str] = {item for item, stack in item_stack_sizes.items() if stack == 1}
-stacking_items: Set[str] = set(item_stack_sizes) - non_stacking_items
-valid_ingredients: Set[str] = stacking_items | fluids
+non_stacking_items: Set[str] = {name for name, item in items.items() if not item.stackable}
+stacking_items: Set[str] = set(items) - non_stacking_items
+valid_ingredients: Set[str] = stacking_items | set(fluids)
 
 # cleanup async helpers
 pool.shutdown()

worlds/factorio/__init__.py

@@ -8,7 +8,7 @@ from .Technologies import base_tech_table, recipe_sources, base_technology_table
     all_ingredient_names, all_product_sources, required_technologies, get_rocket_requirements, \
     progressive_technology_table, common_tech_table, tech_to_progressive_lookup, progressive_tech_table, \
     get_science_pack_pools, Recipe, recipes, technology_table, tech_table, factorio_base_id, useless_technologies, \
-    fluids, stacking_items, valid_ingredients
+    fluids, stacking_items, valid_ingredients, mods
 from .Shapes import get_shapes
 from .Mod import generate_mod
 from .Options import factorio_options, MaxSciencePack, Silo, Satellite, TechTreeInformation, Goal
@@ -54,8 +54,8 @@ class Factorio(World):
     item_name_groups = {
         "Progressive": set(progressive_tech_table.keys()),
     }
-    data_version = 5
-    required_client_version = (0, 3, 0)
+    data_version = 0 if mods else 5
+    required_client_version = (0, 3, 5) if mods else (0, 3, 0)   # TODO: Update required_client_version to (0, 3, 6) when that version releases.
 
     def __init__(self, world, player: int):
         super(Factorio, self).__init__(world, player)
@@ -224,7 +224,7 @@ class Factorio(World):
                 liquids_used += 1 if new_ingredient in fluids else 0
             new_ingredients[new_ingredient] = 1
         return Recipe(original.name, self.get_category(original.category, liquids_used), new_ingredients,
-                      original.products, original.energy)
+                      original.products, original.energy, original.mining, original.unlocked_at_start)
 
     def make_balanced_recipe(self, original: Recipe, pool: typing.Set[str], factor: float = 1,
                              allow_liquids: int = 2) -> Recipe:
@@ -258,6 +258,8 @@ class Factorio(World):
                 ingredient_energy = 2
             if not ingredient_raw:
                 ingredient_raw = 1
+            if not ingredient_energy:
+                ingredient_energy = 1/60
             if remaining_num_ingredients == 1:
                 max_raw = 1.1 * remaining_raw
                 min_raw = 0.9 * remaining_raw
@@ -293,13 +295,18 @@ class Factorio(World):
                 continue  # can't use this ingredient as we already have maximum liquid in our recipe.
 
             ingredient_recipe = recipes.get(ingredient, None)
-            if not ingredient_recipe and ingredient.endswith("-barrel"):
-                ingredient_recipe = recipes.get(f"fill-{ingredient}", None)
+            if not ingredient_recipe and ingredient in all_product_sources:
+                ingredient_recipe = min(all_product_sources[ingredient], key=lambda recipe: recipe.rel_cost)
             if not ingredient_recipe:
                 logging.warning(f"missing recipe for {ingredient}")
                 continue
             ingredient_raw = sum((count for ingredient, count in ingredient_recipe.base_cost.items()))
             ingredient_energy = ingredient_recipe.total_energy
+            if not ingredient_raw:
+                ingredient_raw = 1
+            if not ingredient_energy:
+                ingredient_energy = 1/60
+
             num_raw = remaining_raw / ingredient_raw / remaining_num_ingredients
             num_energy = remaining_energy / ingredient_energy / remaining_num_ingredients
             num = int(min(num_raw, num_energy))
@@ -317,7 +324,7 @@ class Factorio(World):
             logging.warning("could not randomize recipe")
 
         return Recipe(original.name, self.get_category(original.category, liquids_used), new_ingredients,
-                      original.products, original.energy)
+                      original.products, original.energy, original.mining, original.unlocked_at_start)
 
     def set_custom_technologies(self):
         custom_technologies = {}
@@ -330,11 +337,20 @@ class Factorio(World):
         original_rocket_part = recipes["rocket-part"]
         science_pack_pools = get_science_pack_pools()
         valid_pool = sorted(science_pack_pools[self.world.max_science_pack[self.player].get_max_pack()] & valid_ingredients)
+        if len(valid_pool) < 3:
+            # Not enough items in max pool. Extend to entire pool.
+            valid_pool = []
+            for pack in self.world.max_science_pack[self.player].get_ordered_science_packs():
+                valid_pool += sorted(science_pack_pools[pack] & valid_ingredients)
+            if len(valid_pool) < 3:
+                raise Exception("Not enough ingredients available for generation.")
         self.world.random.shuffle(valid_pool)
         self.custom_recipes = {"rocket-part": Recipe("rocket-part", original_rocket_part.category,
                                                      {valid_pool[x]: 10 for x in range(3)},
                                                      original_rocket_part.products,
-                                                     original_rocket_part.energy)}
+                                                     original_rocket_part.energy,
+                                                     original_rocket_part.mining,
+                                                     original_rocket_part.unlocked_at_start)}
 
         if self.world.recipe_ingredients[self.player]:
             valid_pool = []
@@ -363,7 +379,7 @@ class Factorio(World):
         bridge = "ap-energy-bridge"
         new_recipe = self.make_quick_recipe(
             Recipe(bridge, "crafting", {"replace_1": 1, "replace_2": 1, "replace_3": 1},
-                   {bridge: 1}, 10),
+                   {bridge: 1}, 10, False, self.world.energy_link[self.player].value),
             sorted(science_pack_pools[self.world.max_science_pack[self.player].get_ordered_science_packs()[0]]))
         for ingredient_name in new_recipe.ingredients:
             new_recipe.ingredients[ingredient_name] = self.world.random.randint(10, 100)

worlds/factorio/data/fluids.json

@@ -1 +1 @@
-["fluid-unknown","water","crude-oil","steam","heavy-oil","light-oil","petroleum-gas","sulfuric-acid","lubricant"]
+{"fluid-unknown":{"default_temperature":0,"max_temperature":0,"heat_capacity":1000},"water":{"default_temperature":15,"max_temperature":100,"heat_capacity":200},"crude-oil":{"default_temperature":25,"max_temperature":25,"heat_capacity":100},"steam":{"default_temperature":15,"max_temperature":1000,"heat_capacity":200},"heavy-oil":{"default_temperature":25,"max_temperature":25,"heat_capacity":100},"light-oil":{"default_temperature":25,"max_temperature":25,"heat_capacity":100},"petroleum-gas":{"default_temperature":25,"max_temperature":25,"heat_capacity":100},"sulfuric-acid":{"default_temperature":25,"max_temperature":25,"heat_capacity":100},"lubricant":{"default_temperature":25,"max_temperature":25,"heat_capacity":100}}

worlds/factorio/data/machines.json

@@ -1 +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}}
+{"boiler":{"boiler":{"input_fluid":"water","output_fluid":"steam","target_temperature":165,"energy_usage":30000},"common":{"type":"boiler","placeable_by":{"boiler":true}}},"nuclear-reactor":{"fuel_burner":{"categories":{"nuclear":true},"energy_usage":666666.666666666627861559391021728515625},"common":{"type":"reactor","placeable_by":{"nuclear-reactor":true}}},"heat-exchanger":{"boiler":{"input_fluid":"water","output_fluid":"steam","target_temperature":500,"energy_usage":166666.66666666665696538984775543212890625},"common":{"type":"boiler","placeable_by":{"heat-exchanger":true}}},"burner-mining-drill":{"mining":{"categories":{"basic-solid":true},"speed":0.25,"input_fluid_box":false,"output_fluid_box":false},"common":{"type":"mining-drill","placeable_by":{"burner-mining-drill":true}}},"electric-mining-drill":{"mining":{"categories":{"basic-solid":true},"speed":0.5,"input_fluid_box":true,"output_fluid_box":false},"common":{"type":"mining-drill","placeable_by":{"electric-mining-drill":true}}},"offshore-pump":{"offshore-pump":{"fluid":"water","speed":20},"common":{"type":"offshore-pump","placeable_by":{"offshore-pump":true}}},"pumpjack":{"mining":{"categories":{"basic-fluid":true},"speed":1,"input_fluid_box":false,"output_fluid_box":true},"common":{"type":"mining-drill","placeable_by":{"pumpjack":true}}},"stone-furnace":{"crafting":{"speed":1,"categories":{"smelting":true},"input_fluid_box":0,"output_fluid_box":0},"common":{"type":"furnace","placeable_by":{"stone-furnace":true}}},"steel-furnace":{"crafting":{"speed":2,"categories":{"smelting":true},"input_fluid_box":0,"output_fluid_box":0},"common":{"type":"furnace","placeable_by":{"steel-furnace":true}}},"electric-furnace":{"crafting":{"speed":2,"categories":{"smelting":true},"input_fluid_box":0,"output_fluid_box":0},"common":{"type":"furnace","placeable_by":{"electric-furnace":true}}},"assembling-machine-1":{"crafting":{"speed":0.5,"categories":{"crafting":true,"basic-crafting":true,"advanced-crafting":true},"input_fluid_box":0,"output_fluid_box":0},"common":{"type":"assembling-machine","placeable_by":{"assembling-machine-1":true}}},"assembling-machine-2":{"crafting":{"speed":0.75,"categories":{"basic-crafting":true,"crafting":true,"advanced-crafting":true,"crafting-with-fluid":true},"input_fluid_box":1,"output_fluid_box":1},"common":{"type":"assembling-machine","placeable_by":{"assembling-machine-2":true}}},"assembling-machine-3":{"crafting":{"speed":1.25,"categories":{"basic-crafting":true,"crafting":true,"advanced-crafting":true,"crafting-with-fluid":true},"input_fluid_box":1,"output_fluid_box":1},"common":{"type":"assembling-machine","placeable_by":{"assembling-machine-3":true}}},"oil-refinery":{"crafting":{"speed":1,"categories":{"oil-processing":true},"input_fluid_box":2,"output_fluid_box":3},"common":{"type":"assembling-machine","placeable_by":{"oil-refinery":true}}},"chemical-plant":{"crafting":{"speed":1,"categories":{"chemistry":true},"input_fluid_box":2,"output_fluid_box":2},"common":{"type":"assembling-machine","placeable_by":{"chemical-plant":true}}},"centrifuge":{"crafting":{"speed":1,"categories":{"centrifuging":true},"input_fluid_box":0,"output_fluid_box":0},"common":{"type":"assembling-machine","placeable_by":{"centrifuge":true}}},"lab":{"lab":{"inputs":["automation-science-pack","logistic-science-pack","military-science-pack","chemical-science-pack","production-science-pack","utility-science-pack","space-science-pack"]},"common":{"type":"lab","placeable_by":{"lab":true}}},"rocket-silo":{"crafting":{"speed":1,"categories":{"rocket-building":true},"fixed_recipe":"rocket-part","input_fluid_box":0,"output_fluid_box":0},"common":{"type":"rocket-silo","placeable_by":{"rocket-silo":true}}},"character":{"crafting":{"speed":1,"categories":{"crafting":true},"input_fluid_box":0,"output_fluid_box":0},"mining":{"categories":{"basic-solid":true},"speed":0.5,"input_fluid_box":false,"output_fluid_box":false},"common":{"type":"character"}}}

worlds/factorio/data/mod/info.json

@@ -7,7 +7,9 @@
     "description": "Integration client for the Archipelago Randomizer",
     "factorio_version": "1.1",
     "dependencies": [
-	  "base >= 1.1.0",
-	  "? science-not-invited"
-	]
+      "base >= 1.1.0",
+      "? science-not-invited",
+      "? factory-levels",
+      "! archipelago-extractor"
+    ]
 }

worlds/factorio/data/mod_template/control.lua

@@ -13,6 +13,7 @@ GOAL = {{ goal }}
 ARCHIPELAGO_DEATH_LINK_SETTING = "archipelago-death-link-{{ slot_player }}-{{ seed_name }}"
 ENERGY_INCREMENT = {{ energy_link * 1000000 }}
 ENERGY_LINK_EFFICIENCY = 0.75
+CUSTOM_DATA_PACKAGE = {{ custom_data_package }}
 
 if settings.global[ARCHIPELAGO_DEATH_LINK_SETTING].value then
     DEATH_LINK = 1
@@ -249,6 +250,10 @@ script.on_event(defines.events.on_player_main_inventory_changed, update_player_e
 
 function add_samples(force, name, count)
     local function add_to_table(t)
+        if count <= 0 then
+			-- Fixes a bug with single craft, if a recipe gives 0 of a given item.
+			return
+		end
         t[name] = (t[name] or 0) + count
     end
     -- Add to global table of earned samples for future new players
@@ -511,6 +516,10 @@ commands.add_command("ap-get-technology", "Grant a technology, used by the Archi
     local item_name = chunks[1]
     local index = chunks[2]
     local source = chunks[3] or "Archipelago"
+
+    if CUSTOM_DATA_PACKAGE == 1 then
+        item_name = item_id_to_name[item_name] or item_name
+    end
     if index == -1 then -- for coop sync and restoring from an older savegame
         tech = force.technologies[item_name]
         if tech.researched ~= true then
@@ -567,7 +576,8 @@ commands.add_command("ap-rcon-info", "Used by the Archipelago client to get info
         ["slot_name"] = SLOT_NAME,
         ["seed_name"] = SEED_NAME,
         ["death_link"] = DEATH_LINK,
-        ["energy_link"] = ENERGY_INCREMENT
+        ["energy_link"] = ENERGY_INCREMENT,
+        ["custom_data_package"] = CUSTOM_DATA_PACKAGE
     }))
 end)
 
@@ -594,3 +604,4 @@ end)
 
 -- data
 progressive_technologies = {{ dict_to_lua(progressive_technology_table) }}
+item_id_to_name = {{ dict_to_lua(item_id_to_name) }}

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

@@ -141,6 +141,9 @@ end
 {# This got complex, but seems to be required to hit all corner cases #}
 function adjust_energy(recipe_name, factor)
     local recipe = data.raw.recipe[recipe_name]
+    if recipe == nil then
+        error("Some mod that is installed has removed recipe \"" .. recipe_name .. "\"")
+    end
     local energy = recipe.energy_required
 
     if (recipe.normal ~= nil) then
@@ -168,6 +171,9 @@ end
 
 function set_energy(recipe_name, energy)
     local recipe = data.raw.recipe[recipe_name]
+    if recipe == nil then
+        error("Some mod that is installed has removed recipe \"" .. recipe_name .. "\"")
+    end
 
     if (recipe.normal ~= nil) then
         recipe.normal.energy_required = energy
@@ -183,11 +189,26 @@ end
 data.raw["assembling-machine"]["assembling-machine-1"].crafting_categories = table.deepcopy(data.raw["assembling-machine"]["assembling-machine-3"].crafting_categories)
 data.raw["assembling-machine"]["assembling-machine-2"].crafting_categories = table.deepcopy(data.raw["assembling-machine"]["assembling-machine-3"].crafting_categories)
 data.raw["assembling-machine"]["assembling-machine-1"].fluid_boxes = table.deepcopy(data.raw["assembling-machine"]["assembling-machine-2"].fluid_boxes)
+if mods["factory-levels"] then
+    -- Factory-Levels allows the assembling machines to get faster (and depending on settings), more productive at crafting products, the more the
+    -- assembling machine crafts the product.  If the machine crafts enough, it may auto-upgrade to the next tier.
+    for i = 1, 25, 1 do
+        data.raw["assembling-machine"]["assembling-machine-1-level-" .. i].crafting_categories = table.deepcopy(data.raw["assembling-machine"]["assembling-machine-3"].crafting_categories)
+        data.raw["assembling-machine"]["assembling-machine-1-level-" .. i].fluid_boxes = table.deepcopy(data.raw["assembling-machine"]["assembling-machine-2"].fluid_boxes)
+    end
+    for i = 1, 50, 1 do
+        data.raw["assembling-machine"]["assembling-machine-2-level-" .. i].crafting_categories = table.deepcopy(data.raw["assembling-machine"]["assembling-machine-3"].crafting_categories)
+    end
+end
+
 data.raw["ammo"]["artillery-shell"].stack_size = 10
 
 {# each randomized tech gets set to be invisible, with new nodes added that trigger those #}
 {%- for original_tech_name, item_name, receiving_player, advancement in locations %}
 original_tech = technologies["{{original_tech_name}}"]
+if original_tech == nil then
+    error("Some mod that is installed has removed tech \"{{original_tech_name}}\"")
+end
 {#- 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 #}
@@ -220,13 +241,13 @@ data:extend{new_tree_copy}
 {% endfor %}
 {% if recipe_time_scale %}
 {%- for recipe_name, recipe in recipes.items() %}
-{%- if recipe.category not in ("basic-solid", "basic-fluid") %}
+{%- if not recipe.mining and not recipe.burning %}
 adjust_energy("{{ recipe_name }}", {{ flop_random(*recipe_time_scale) }})
 {%- endif %}
 {%- endfor -%}
 {% elif recipe_time_range %}
 {%- for recipe_name, recipe in recipes.items() %}
-{%- if recipe.category not in ("basic-solid", "basic-fluid") %}
+{%- if not recipe.mining and not recipe.burning %}
 set_energy("{{ recipe_name }}", {{ flop_random(*recipe_time_range) }})
 {%- endif %}
 {%- endfor -%}

worlds/factorio/data/mod_template/data.lua

@@ -1,4 +1,15 @@
 {% from "macros.lua" import dict_to_lua %}
+-- TODO: Replace the tinting code with an actual rendered picture of the energy bridge icon.
+-- This tint is so that one is less likely to accidentally mass-produce energy-bridges, then wonder why their rocket is not building.
+function energy_bridge_tint()
+    return { r = 0, g = 1, b = 0.667, a = 1}
+end
+function tint_icon(obj, tint)
+    obj.icons = { {icon = obj.icon, icon_size = obj.icon_size, icon_mipmaps = obj.icon_mipmaps, tint = tint} }
+    obj.icon = nil
+    obj.icon_size = nil
+    obj.icon_mipmaps = nil
+end
 local energy_bridge = table.deepcopy(data.raw["accumulator"]["accumulator"])
 energy_bridge.name = "ap-energy-bridge"
 energy_bridge.minable.result = "ap-energy-bridge"
@@ -6,12 +17,20 @@ energy_bridge.localised_name = "Archipelago EnergyLink Bridge"
 energy_bridge.energy_source.buffer_capacity = "5MJ"
 energy_bridge.energy_source.input_flow_limit = "1MW"
 energy_bridge.energy_source.output_flow_limit = "1MW"
+tint_icon(energy_bridge, energy_bridge_tint())
+energy_bridge.picture.layers[1].tint = energy_bridge_tint()
+energy_bridge.picture.layers[1].hr_version.tint = energy_bridge_tint()
+energy_bridge.charge_animation.layers[1].layers[1].tint = energy_bridge_tint()
+energy_bridge.charge_animation.layers[1].layers[1].hr_version.tint = energy_bridge_tint()
+energy_bridge.discharge_animation.layers[1].layers[1].tint = energy_bridge_tint()
+energy_bridge.discharge_animation.layers[1].layers[1].hr_version.tint = energy_bridge_tint()
 data.raw["accumulator"]["ap-energy-bridge"] = energy_bridge
 
 local energy_bridge_item = table.deepcopy(data.raw["item"]["accumulator"])
 energy_bridge_item.name = "ap-energy-bridge"
 energy_bridge_item.localised_name = "Archipelago EnergyLink Bridge"
 energy_bridge_item.place_result = energy_bridge.name
+tint_icon(energy_bridge_item, energy_bridge_tint())
 data.raw["item"]["ap-energy-bridge"] = energy_bridge_item
 
 local energy_bridge_recipe = table.deepcopy(data.raw["recipe"]["accumulator"])

worlds/factorio/data/mod_template/settings.lua

@@ -1,3 +1,21 @@
+-- Find out if more than one AP mod is loaded, and if so, error out.
+function mod_is_AP(str)
+    -- lua string.match is way more restrictive than regex. Regex would be "^AP-W?\d{20}-P[1-9]\d*-.+$"
+	local result = string.match(str, "^AP%-W?%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%-P[1-9]%d-%-.+$")
+	if result ~= nil then
+		log("Archipelago Mod: " .. result .. " is loaded.")
+	end
+	return result ~= nil
+end
+local ap_mod_count = 0
+for name, _ in pairs(mods) do
+    if mod_is_AP(name) then
+        ap_mod_count = ap_mod_count + 1
+        if ap_mod_count > 1 then
+            error("More than one Archipelago Factorio mod is loaded.")
+        end
+    end
+end
 data:extend({
     {
         type = "bool-setting",

worlds/factorio/data/mods.json

@@ -0,0 +1 @@
+{"base":"1.1.69","archipelago-extractor":"1.1.1"}

worlds/ff1/Items.py

@@ -20,7 +20,7 @@ FF1_STARTER_ITEMS = [
 
 FF1_PROGRESSION_LIST = [
     "Rod", "Cube", "Lute", "Key", "Chime", "Oxyale",
-    "Ship", "Canoe", "Floater", "Canal",
+    "Ship", "Canoe", "Floater", "Mark", "Sigil", "Canal",
     "Crown", "Crystal", "Herb", "Tnt", "Adamant", "Slab", "Ruby", "Bottle",
     "Shard",
     "EarthOrb", "FireOrb", "WaterOrb", "AirOrb"

worlds/ff1/__init__.py

@@ -31,7 +31,7 @@ class FF1World(World):
     game = "Final Fantasy"
     topology_present = False
     remote_items = True
-    data_version = 1
+    data_version = 2
     remote_start_inventory = True
 
     ff1_items = FF1Items()
@@ -66,7 +66,10 @@ class FF1World(World):
             def goal_rule_and_shards(state):
                 return goal_rule(state) and state.has("Shard", self.player, 32)
             terminated_event.access_rule = goal_rule_and_shards
-
+        if "MARK" in items.keys():
+            # Fail generation for Noverworld and provide link to old FFR website
+            raise Exception("FFR Noverworld seeds must be generated on an older version of FFR. Please ensure you generated the settings using "
+                            "4-4-0.finalfantasyrandomizer.com")
         menu_region.locations.append(terminated_event)
         self.world.regions += [menu_region]
 

worlds/ff1/data/items.json

@@ -190,5 +190,7 @@
   "Ship": 480,
   "Bridge": 488,
   "Canal": 492,
-  "Canoe": 498
+  "Canoe": 498,
+  "Sigil": 499,
+  "Mark": 500
 }

worlds/generic/Rules.py

@@ -49,11 +49,11 @@ def exclusion_rules(world, player: int, exclude_locations: typing.Set[str]):
             location.progress_type = LocationProgressType.EXCLUDED
 
 
-def set_rule(spot, rule: CollectionRule):
+def set_rule(spot: typing.Union["BaseClasses.Location", "BaseClasses.Entrance"], rule: CollectionRule):
     spot.access_rule = rule
 
 
-def add_rule(spot, rule: CollectionRule, combine='and'):
+def add_rule(spot: typing.Union["BaseClasses.Location", "BaseClasses.Entrance"], rule: CollectionRule, combine='and'):
     old_rule = spot.access_rule
     if combine == 'or':
         spot.access_rule = lambda state: rule(state) or old_rule(state)
@@ -61,35 +61,37 @@ def add_rule(spot, rule: CollectionRule, combine='and'):
         spot.access_rule = lambda state: rule(state) and old_rule(state)
 
 
-def forbid_item(location, item: str, player: int):
+def forbid_item(location: "BaseClasses.Location", item: str, player: int):
     old_rule = location.item_rule
     location.item_rule = lambda i: (i.name != item or i.player != player) and old_rule(i)
 
 
-def forbid_items_for_player(location, items: typing.Set[str], player: int):
+def forbid_items_for_player(location: "BaseClasses.Location", items: typing.Set[str], player: int):
     old_rule = location.item_rule
     location.item_rule = lambda i: (i.player != player or i.name not in items) and old_rule(i)
 
 
-def forbid_items(location, items: typing.Set[str]):
+def forbid_items(location: "BaseClasses.Location", items: typing.Set[str]):
     """unused, but kept as a debugging tool."""
     old_rule = location.item_rule
     location.item_rule = lambda i: i.name not in items and old_rule(i)
 
 
-def add_item_rule(location, rule: ItemRule):
+def add_item_rule(location: "BaseClasses.Location", rule: ItemRule):
     old_rule = location.item_rule
     location.item_rule = lambda item: rule(item) and old_rule(item)
 
 
-def item_in_locations(state, item: str, player: int, locations: typing.Sequence):
+def item_in_locations(state: "BaseClasses.CollectionState", item: str, player: int,
+                      locations: typing.Sequence["BaseClasses.Location"]) -> bool:
     for location in locations:
         if item_name(state, location[0], location[1]) == (item, player):
             return True
     return False
 
 
-def item_name(state, location: str, player: int) -> typing.Optional[typing.Tuple[str, int]]:
+def item_name(state: "BaseClasses.CollectionState", location: str, player: int) -> \
+        typing.Optional[typing.Tuple[str, int]]:
     location = state.world.get_location(location, player)
     if location.item is None:
         return None

worlds/hk/Options.py

@@ -409,7 +409,6 @@ class DeathLink(Choice):
     shade: DeathLink functions like a normal death if you do not already have a shade, shadeless otherwise.
     """
     option_off = 0
-    alias_false = 0
     alias_no = 0
     alias_true = 1
     alias_on = 1
@@ -435,10 +434,8 @@ class CostSanity(Choice):
     These costs can be in Geo (except Grubfather, Seer and Eggshop), Grubs, Charms, Essence and/or Rancid Eggs
     """
     option_off = 0
-    alias_false = 0
     alias_no = 0
     option_on = 1
-    alias_true = 1
     alias_yes = 1
     option_shopsonly = 2
     option_notshops = 3

worlds/minecraft/Rules.py

@@ -276,10 +276,10 @@ def set_advancement_rules(world: MultiWorld, player: int):
 
     # 1.19 advancements
 
-    # can make a cake, and can reach a pillager outposts for allays
-    set_rule(world.get_location("Birthday Song", player), lambda state: state.can_reach("The Lie", "Location", player))
-    # find allay and craft a noteblock
-    set_rule(world.get_location("You've Got a Friend in Me", player), lambda state: state.has("Progressive Tools", player, 2) and state._mc_has_iron_ingots(player))
+    # can make a cake, and a noteblock, and can reach a pillager outposts for allays
+    set_rule(world.get_location("Birthday Song", player), lambda state: state.can_reach("The Lie", "Location", player) and state.has("Progressive Tools", player, 2) and state._mc_has_iron_ingots(player))
+    # can get to outposts.
+    # set_rule(world.get_location("You've Got a Friend in Me", player), lambda state: True)
     # craft bucket and adventure to find frog spawning biome
     set_rule(world.get_location("Bukkit Bukkit", player), lambda state: state.has("Bucket", player) and state._mc_has_iron_ingots(player) and state._mc_can_adventure(player))
     # I don't like this one its way to easy to get. just a pain to find.

worlds/minecraft/docs/en_Minecraft.md

@@ -7,9 +7,9 @@ config file.
 
 ## What does randomization do to this game?
 
-Recipes are removed from the crafting book and shuffled into the item pool. It can also optionally change which
+Some recipes are locked from being able to be crafted and shuffled into the item pool. It can also optionally change which
 structures appear in each dimension. Crafting recipes are re-learned when they are received from other players as item
-checks, and occasionally when completing your own achievements.
+checks, and occasionally when completing your own achievements. See below for which recipes are shuffled.
 
 ## What is considered a location check in minecraft?
 
@@ -25,3 +25,86 @@ inventory directly.
 
 Victory is achieved when the player kills the Ender Dragon, enters the portal in The End, and completes the credits
 sequence either by skipping it or watching hit play out.
+
+## Which recipes are locked?
+
+* Archery
+  * Bow
+  * Arrow
+  * Crossbow
+* Brewing
+  * Blaze Powder
+  * Brewing Stand
+* Enchanting
+  * Enchanting Table
+  * Bookshelf
+* Bucket
+* Flint & Steel
+* All Beds
+* Bottles
+* Shield
+* Fishing Rod
+  * Fishing Rod
+  * Carrot on a Stick
+  * Warped Fungus on a Stick
+* Campfire
+  * Campfire
+  * Soul Campfire
+* Spyglass
+* Lead
+* Progressive Weapons
+  * Tier I
+    * Stone Sword
+    * Stone Axe
+  * Tier II
+    * Iron Sword
+    * Iron Axe
+  * Tier III
+    * Diamond Sword
+    * Diamond Axe
+* Progessive Tools
+  * Tier I
+    * Stone Shovel
+    * Stone Hoe
+  * Tier II
+    * Iron Shovel
+    * Iron Hoe
+  * Tier III
+    * Diamond Shovel
+    * Diamond Hoe
+    * Netherite Ingot
+* Progressive Armor
+  * Tier I
+    * Iron Helmet
+    * Iron Chestplate
+    * Iron Leggings
+    * Iron Boots
+  * Tier II
+    * Diamond Helmet
+    * Diamond Chestplate
+    * Diamond Leggings
+    * Diamond Boots
+* Progressive Resource Crafting
+  * Tier I
+    * Iron Ingot from Nuggets
+    * Iron Nugget
+    * Gold Ingot from Nuggets
+    * Gold Nugget
+    * Furnace
+    * Blast Furnace
+  * Tier II
+    * Redstone
+    * Redstone Block
+    * Glowstone
+    * Iron Ingot from Iron Block
+    * Iron Block
+    * Gold Ingot from Gold Block
+    * Gold Block
+    * Diamond
+    * Diamond Block
+    * Netherite Block
+    * Netherite Ingot from Netherite Block
+    * Anvil
+    * Emerald
+    * Emerald Block
+    * Copper Block

worlds/oot/Hints.py

@@ -129,6 +129,8 @@ def getItemGenericName(item):
 
 
 def isRestrictedDungeonItem(dungeon, item):
+    if not isinstance(item, OOTItem):
+        return False
     if (item.map or item.compass) and dungeon.world.shuffle_mapcompass == 'dungeon':
         return item in dungeon.dungeon_items
     if item.type == 'SmallKey' and dungeon.world.shuffle_smallkeys == 'dungeon':

worlds/oot/ItemPool.py

@@ -1388,6 +1388,10 @@ def get_pool_core(world):
         remove_junk_pool = list(remove_junk_pool) + ['Recovery Heart', 'Bombs (20)', 'Arrows (30)', 'Ice Trap']
 
         junk_candidates = [item for item in pool if item in remove_junk_pool]
+        if len(pending_junk_pool) > len(junk_candidates):
+            excess = len(pending_junk_pool) - len(junk_candidates)
+            if world.triforce_hunt:
+                raise RuntimeError(f"Items in the pool for player {world.player} exceed locations. Add {excess} location(s) or remove {excess} triforce piece(s).")
         while pending_junk_pool:
             pending_item = pending_junk_pool.pop()
             if not junk_candidates:

worlds/oot/Items.py

@@ -22,6 +22,12 @@ def ap_id_to_oot_data(ap_id):
         raise Exception(f'Could not find desired item ID: {ap_id}')
 
 
+def oot_is_item_of_type(item, item_type):
+    if not isinstance(item, OOTItem):
+        return False
+    return item.type == item_type
+
+
 class OOTItem(Item):
     game: str = "Ocarina of Time"
     type: str
@@ -43,7 +49,6 @@ class OOTItem(Item):
         self.type = type
         self.index = index
         self.special = special or {}
-        self.looks_like_item = None
         self.price = special.get('price', None) if special else None
         self.internal = False
 

worlds/oot/Options.py

@@ -101,7 +101,6 @@ class InteriorEntrances(Choice):
     option_off = 0
     option_simple = 1
     option_all = 2
-    alias_false = 0
     alias_true = 2
 
 
@@ -141,7 +140,6 @@ class MixEntrancePools(Choice):
     option_off = 0
     option_indoor = 1
     option_all = 2
-    alias_false = 0
 
 
 class DecoupleEntrances(Toggle):
@@ -158,12 +156,12 @@ class TriforceGoal(Range):
     """Number of Triforce pieces required to complete the game."""
     display_name = "Required Triforce Pieces"
     range_start = 1
-    range_end = 100
+    range_end = 80
     default = 20
 
 
 class ExtraTriforces(Range):
-    """Percentage of additional Triforce pieces in the pool, separate from the item pool setting."""
+    """Percentage of additional Triforce pieces in the pool. With high numbers, you may need to randomize additional locations to have enough items."""
     display_name = "Percentage of Extra Triforce Pieces"
     range_start = 0
     range_end = 100
@@ -308,7 +306,6 @@ class ShopShuffle(Choice):
     option_off = 0
     option_fixed_number = 1
     option_random_number = 2
-    alias_false = 0
 
 
 class ShopSlots(Range):
@@ -326,7 +323,6 @@ class TokenShuffle(Choice):
     option_dungeons = 1
     option_overworld = 2
     option_all = 3
-    alias_false = 0
 
 
 class ScrubShuffle(Choice): 
@@ -336,7 +332,6 @@ class ScrubShuffle(Choice):
     option_low = 1
     option_regular = 2
     option_random_prices = 3
-    alias_false = 0
     alias_affordable = 1
     alias_expensive = 2
 
@@ -569,7 +564,6 @@ class Hints(Choice):
     option_agony = 2
     option_always = 3
     default = 3
-    alias_false = 0
 
 
 class MiscHints(DefaultOnToggle):
@@ -673,8 +667,6 @@ class IceTraps(Choice):
     option_mayhem = 3
     option_onslaught = 4
     default = 1
-    alias_false = 0
-    alias_true = 2
     alias_extra = 2
 
 
@@ -742,7 +734,6 @@ class Music(Choice):
     option_normal = 0
     option_off = 1
     option_randomized = 2
-    alias_false = 1
 
 
 class BackgroundMusic(Music):

worlds/oot/Patches.py

@@ -1844,7 +1844,7 @@ def write_rom_item(rom, item_id, item):
 
 
 def get_override_table(world):
-    return list(filter(lambda val: val != None, map(partial(get_override_entry, world.player), world.world.get_filled_locations(world.player))))
+    return list(filter(lambda val: val != None, map(partial(get_override_entry, world), world.world.get_filled_locations(world.player))))
 
 
 override_struct = struct.Struct('>xBBBHBB') # match override_t in get_items.c
@@ -1852,10 +1852,10 @@ def get_override_table_bytes(override_table):
     return b''.join(sorted(itertools.starmap(override_struct.pack, override_table)))
 
 
-def get_override_entry(player_id, location):
+def get_override_entry(ootworld, location):
     scene = location.scene
     default = location.default
-    player_id = 0 if player_id == location.item.player else min(location.item.player, 255)
+    player_id = 0 if ootworld.player == location.item.player else min(location.item.player, 255)
     if location.item.game != 'Ocarina of Time': 
         # This is an AP sendable. It's guaranteed to not be None. 
         if location.item.advancement:
@@ -1869,7 +1869,7 @@ def get_override_entry(player_id, location):
 
     if location.item.trap:
         item_id = 0x7C  # Ice Trap ID, to get "X is a fool" message
-        looks_like_item_id = location.item.looks_like_item.index
+        looks_like_item_id = ootworld.trap_appearances[location.address].index
     else:
         looks_like_item_id = 0
 
@@ -2091,7 +2091,8 @@ def get_locked_doors(rom, world):
                 return [0x00D4 + scene * 0x1C + 0x04 + flag_byte, flag_bits]
 
         # If boss door, set the door's unlock flag
-        if (world.shuffle_bosskeys == 'remove' and scene != 0x0A) or (world.shuffle_ganon_bosskey == 'remove' and scene == 0x0A):
+        if (world.shuffle_bosskeys == 'remove' and scene != 0x0A) or (
+            world.shuffle_ganon_bosskey == 'remove' and scene == 0x0A and not world.triforce_hunt):
             if actor_id == 0x002E and actor_type == 0x05:
                 return [0x00D4 + scene * 0x1C + 0x04 + flag_byte, flag_bits]
 
@@ -2109,23 +2110,20 @@ def place_shop_items(rom, world, shop_items, messages, locations, init_shop_id=F
             rom.write_int16(location.address1, location.item.index)
         else:
             if location.item.trap:
-                item_display = location.item.looks_like_item
-            elif location.item.game != "Ocarina of Time": 
-                item_display = location.item
-                if location.item.advancement:
-                    item_display.index = 0xCB
-                else:
-                    item_display.index = 0xCC
-                item_display.special = {}
+                item_display = world.trap_appearances[location.address]
             else:
                 item_display = location.item
 
             # bottles in shops should look like empty bottles
             # so that that are different than normal shop refils
-            if 'shop_object' in item_display.special:
-                rom_item = read_rom_item(rom, item_display.special['shop_object'])
+            if location.item.trap or location.item.game == "Ocarina of Time":
+                if 'shop_object' in item_display.special:
+                    rom_item = read_rom_item(rom, item_display.special['shop_object'])
+                else:
+                    rom_item = read_rom_item(rom, item_display.index)
             else:
-                rom_item = read_rom_item(rom, item_display.index)
+                display_index = 0xCB if location.item.advancement else 0xCC
+                rom_item = read_rom_item(rom, display_index)
 
             shop_objs.add(rom_item['object_id'])
             shop_id = world.current_shop_id

worlds/oot/Rules.py

@@ -3,6 +3,7 @@ import logging
 
 from .SaveContext import SaveContext
 from .Regions import TimeOfDay
+from .Items import oot_is_item_of_type
 
 from BaseClasses import CollectionState
 from worlds.generic.Rules import set_rule, add_rule, add_item_rule, forbid_item
@@ -138,7 +139,7 @@ def set_rules(ootworld):
         # Sheik in Ice Cavern is the only song location in a dungeon; need to ensure that it cannot be anything else.
         # This is required if map/compass included, or any_dungeon shuffle.
         location = world.get_location('Sheik in Ice Cavern', player)
-        add_item_rule(location, lambda item: item.player == player and item.type == 'Song')
+        add_item_rule(location, lambda item: item.player == player and oot_is_item_of_type(item, 'Song'))
 
     if ootworld.skip_child_zelda:
         # If skip child zelda is on, the item at Song from Impa must be giveable by the save context. 
@@ -181,7 +182,7 @@ def set_shop_rules(ootworld):
     wallet = ootworld.parser.parse_rule('Progressive_Wallet')
     wallet2 = ootworld.parser.parse_rule('(Progressive_Wallet, 2)')
 
-    for location in filter(lambda location: location.item and location.item.type == 'Shop', ootworld.get_locations()):
+    for location in filter(lambda location: location.item and oot_is_item_of_type(location.item, 'Shop'), ootworld.get_locations()):
         # Add wallet requirements
         if location.item.name in ['Buy Arrows (50)', 'Buy Fish', 'Buy Goron Tunic', 'Buy Bombchu (20)', 'Buy Bombs (30)']:
             add_rule(location, wallet)

worlds/oot/__init__.py

@@ -8,7 +8,7 @@ logger = logging.getLogger("Ocarina of Time")
 from .Location import OOTLocation, LocationFactory, location_name_to_id
 from .Entrance import OOTEntrance
 from .EntranceShuffle import shuffle_random_entrances, entrance_shuffle_table, EntranceShuffleError
-from .Items import OOTItem, item_table, oot_data_to_ap_id
+from .Items import OOTItem, item_table, oot_data_to_ap_id, oot_is_item_of_type
 from .ItemPool import generate_itempool, add_dungeon_items, get_junk_item, get_junk_pool
 from .Regions import OOTRegion, TimeOfDay
 from .Rules import set_rules, set_shop_rules, set_entrances_based_rules
@@ -178,6 +178,10 @@ class OOTWorld(World):
         if self.skip_child_zelda:
             self.shuffle_weird_egg = False
 
+        # Ganon boss key should not be in itempool in triforce hunt
+        if self.triforce_hunt:
+            self.shuffle_ganon_bosskey = 'remove'
+
         # Determine skipped trials in GT
         # This needs to be done before the logic rules in GT are parsed
         trial_list = ['Forest', 'Fire', 'Water', 'Spirit', 'Shadow', 'Light']
@@ -186,7 +190,11 @@ class OOTWorld(World):
 
         # Determine which dungeons are MQ
         # Possible future plan: allow user to pick which dungeons are MQ
-        mq_dungeons = self.world.random.sample(dungeon_table, self.mq_dungeons)
+        if self.logic_rules == 'glitchless':
+            mq_dungeons = self.world.random.sample(dungeon_table, self.mq_dungeons)
+        else:
+            self.mq_dungeons = 0
+            mq_dungeons = []
         self.dungeon_mq = {item['name']: (item in mq_dungeons) for item in dungeon_table}
 
         # Determine tricks in logic
@@ -793,7 +801,7 @@ class OOTWorld(World):
         # This includes all locations for which show_in_spoiler is false, and shuffled shop items.
         for loc in self.get_locations():
             if loc.address is not None and (
-                    not loc.show_in_spoiler or (loc.item is not None and loc.item.type == 'Shop')
+                    not loc.show_in_spoiler or oot_is_item_of_type(loc.item, 'Shop')
                     or (self.skip_child_zelda and loc.name in ['HC Zeldas Letter', 'Song from Impa'])):
                 loc.address = None
 
@@ -803,9 +811,10 @@ class OOTWorld(World):
 
         with i_o_limiter:
             # Make traps appear as other random items
-            ice_traps = [loc.item for loc in self.get_locations() if loc.item.trap]
-            for trap in ice_traps:
-                trap.looks_like_item = self.create_item(self.world.slot_seeds[self.player].choice(self.fake_items).name)
+            trap_location_ids = [loc.address for loc in self.get_locations() if loc.item.trap]
+            self.trap_appearances = {}
+            for loc_id in trap_location_ids:
+                self.trap_appearances[loc_id] = self.create_item(self.world.slot_seeds[self.player].choice(self.fake_items).name)
 
             # Seed hint RNG, used for ganon text lines also
             self.hint_rng = self.world.slot_seeds[self.player]
@@ -869,11 +878,11 @@ class OOTWorld(World):
                         autoworld.major_item_locations.append(loc)
 
                     if loc.game == "Ocarina of Time" and loc.item.code and (not loc.locked or
-                        (loc.item.type == 'Song' or
-                            (loc.item.type == 'SmallKey'         and world.worlds[loc.player].shuffle_smallkeys     == 'any_dungeon') or
-                            (loc.item.type == 'HideoutSmallKey'  and world.worlds[loc.player].shuffle_fortresskeys  == 'any_dungeon') or
-                            (loc.item.type == 'BossKey'          and world.worlds[loc.player].shuffle_bosskeys      == 'any_dungeon') or
-                            (loc.item.type == 'GanonBossKey'     and world.worlds[loc.player].shuffle_ganon_bosskey == 'any_dungeon'))):
+                        (oot_is_item_of_type(loc.item, 'Song') or
+                            (oot_is_item_of_type(loc.item, 'SmallKey')         and world.worlds[loc.player].shuffle_smallkeys     == 'any_dungeon') or
+                            (oot_is_item_of_type(loc.item, 'HideoutSmallKey')  and world.worlds[loc.player].shuffle_fortresskeys  == 'any_dungeon') or
+                            (oot_is_item_of_type(loc.item, 'BossKey')          and world.worlds[loc.player].shuffle_bosskeys      == 'any_dungeon') or
+                            (oot_is_item_of_type(loc.item, 'GanonBossKey')     and world.worlds[loc.player].shuffle_ganon_bosskey == 'any_dungeon'))):
                         if loc.player in barren_hint_players:
                             hint_area = get_hint_area(loc)
                             items_by_region[loc.player][hint_area]['weight'] += 1
@@ -888,7 +897,7 @@ class OOTWorld(World):
             elif barren_hint_players or woth_hint_players:  # Check only relevant oot locations for barren/woth
                 for player in (barren_hint_players | woth_hint_players):
                     for loc in world.worlds[player].get_locations():
-                        if loc.item.code and (not loc.locked or loc.item.type == 'Song'):
+                        if loc.item.code and (not loc.locked or oot_is_item_of_type(loc.item, 'Song')):
                             if player in barren_hint_players:
                                 hint_area = get_hint_area(loc)
                                 items_by_region[player][hint_area]['weight'] += 1

worlds/raft/Options.py

@@ -1,8 +1,4 @@
-from Options import Range, Toggle, DefaultOnToggle, Choice
-
-class UseResourcePacks(DefaultOnToggle):
-    """Uses Resource Packs to fill out the item pool from Raft. Resource Packs have basic earlygame items such as planks, plastic, or food."""
-    display_name = "Use resource packs"
+from Options import Range, Toggle, DefaultOnToggle, Choice, DeathLink
 
 class MinimumResourcePackAmount(Range):
     """The minimum amount of resources available in a resource pack"""
@@ -19,23 +15,30 @@ class MaximumResourcePackAmount(Range):
     default = 5
 
 class DuplicateItems(Choice):
-    """Adds duplicates of items to the item pool. These will be selected alongside
-    Resource Packs (if configured). Note that there are not many progression items,
-    and selecting Progression may produce many of the same duplicate item."""
+    """Adds duplicates of items to the item pool (if configured in Filler items). These will be selected alongside Resource Packs (if configured). Note that there are not many progression items, and selecting Progression may produce many of the same duplicate item."""
     display_name = "Duplicate items"
-    option_disabled = 0
-    option_progression = 1
-    option_non_progression = 2
-    option_any = 3
+    option_progression = 0
+    option_non_progression = 1
+    option_any = 2
+    default = 2
+
+class FillerItemTypes(Choice):
+    """Determines whether to use Resource Packs, Duplicate Items (as configured), or both."""
+    display_name = "Filler items"
+    option_resource_packs = 0
+    option_duplicates = 1
+    option_both = 2
 
 class IslandFrequencyLocations(Choice):
     """Sets where frequencies for story islands are located."""
     display_name = "Frequency locations"
     option_vanilla = 0
     option_random_on_island = 1
-    option_progressive = 2
-    option_anywhere = 3
-    default = 1
+    option_random_island_order = 2
+    option_random_on_island_random_order = 3
+    option_progressive = 4
+    option_anywhere = 5
+    default = 2
 
 class IslandGenerationDistance(Choice):
     """Sets how far away islands spawn from you when you input their coordinates into the Receiver."""
@@ -56,7 +59,7 @@ class ProgressiveItems(DefaultOnToggle):
     display_name = "Progressive items"
 
 class BigIslandEarlyCrafting(Toggle):
-    """Allows recipes that require items from big islands (eg leather) to lock earlygame items like the Receiver, Bolt, or Smelter."""
+    """Allows recipes that require items from big islands (eg leather) to lock earlygame items like the Receiver, Bolt, or Smelter. Big islands are available from the start of the game, however it can take a long time to find them."""
     display_name = "Early recipes behind big islands"
 
 class PaddleboardMode(Toggle):
@@ -64,14 +67,15 @@ class PaddleboardMode(Toggle):
     display_name = "Paddleboard Mode"
 
 raft_options = {
-    "use_resource_packs": UseResourcePacks,
     "minimum_resource_pack_amount": MinimumResourcePackAmount,
     "maximum_resource_pack_amount": MaximumResourcePackAmount,
     "duplicate_items": DuplicateItems,
+    "filler_item_types": FillerItemTypes,
     "island_frequency_locations": IslandFrequencyLocations,
     "island_generation_distance": IslandGenerationDistance,
     "expensive_research": ExpensiveResearch,
     "progressive_items": ProgressiveItems,
     "big_island_early_crafting": BigIslandEarlyCrafting,
-    "paddleboard_mode": PaddleboardMode
+    "paddleboard_mode": PaddleboardMode,
+    "death_link": DeathLink
 }

worlds/raft/Rules.py

@@ -12,9 +12,6 @@ class RaftLogic(LogicMixin):
 
     def raft_can_smelt_items(self, player):
         return self.has("Smelter", player)
-    
-    def raft_can_find_titanium(self, player):
-        return self.has("Metal detector", player)
 
     def raft_can_craft_bolt(self, player):
         return self.raft_can_smelt_items(player) and self.has("Bolt", player)
@@ -27,12 +24,19 @@ class RaftLogic(LogicMixin):
 
     def raft_can_craft_circuitBoard(self, player):
         return self.raft_can_smelt_items(player) and self.has("Circuit board", player)
+    
+    def raft_can_craft_shovel(self, player):
+        return self.raft_can_smelt_items(player) and self.has("Shovel", player) and self.raft_can_craft_bolt(player)
 
     def raft_can_craft_reciever(self, player):
         return self.raft_can_craft_circuitBoard(player) and self.raft_can_craft_hinge(player) and self.has("Receiver", player)
 
     def raft_can_craft_antenna(self, player):
         return self.raft_can_craft_circuitBoard(player) and self.raft_can_craft_bolt(player) and self.has("Antenna", player)
+    
+    def raft_can_find_titanium(self, player):
+        return (self.has("Metal detector", player) and self.raft_can_craft_battery(player)
+            and self.raft_can_craft_shovel(player))
 
     def raft_can_craft_plasticBottle(self, player):
         return self.raft_can_smelt_items(player) and self.has("Empty bottle", player)
@@ -60,7 +64,7 @@ class RaftLogic(LogicMixin):
         return self.raft_can_craft_hinge(player) and self.raft_can_craft_bolt(player) and self.has("Zipline tool", player)
 
     def raft_can_get_dirt(self, player):
-        return self.raft_can_smelt_items(player) and self.raft_can_craft_bolt(player) and self.has("Shovel", player)
+        return self.raft_can_craft_shovel(player) and self.raft_big_islands_available(player)
 
     def raft_can_craft_grassPlot(self, player):
         return self.raft_can_get_dirt(player) and self.has("Grass plot", player)
@@ -88,60 +92,69 @@ class RaftLogic(LogicMixin):
         return self.raft_can_access_radio_tower(player)
 
     def raft_can_access_vasagatan(self, player):
-        return self.raft_can_complete_radio_tower(player) and self.raft_can_navigate(player) and self.has("Vasagatan Frequency", player)
+        return self.raft_can_navigate(player) and self.has("Vasagatan Frequency", player)
 
     def raft_can_complete_vasagatan(self, player):
         return self.raft_can_access_vasagatan(player)
 
     def raft_can_access_balboa_island(self, player):
-        return (self.raft_can_complete_vasagatan(player)
-            and self.raft_can_drive(player)
-            and self.has("Balboa Island Frequency", player))
+        return self.raft_can_drive(player) and self.has("Balboa Island Frequency", player)
 
     def raft_can_complete_balboa_island(self, player):
         return self.raft_can_access_balboa_island(player) and self.raft_can_craft_machete(player)
 
     def raft_can_access_caravan_island(self, player):
-        return self.raft_can_complete_balboa_island(player) and self.raft_can_drive(player) and self.has("Caravan Island Frequency", player)
+        return self.raft_can_drive(player) and self.has("Caravan Island Frequency", player)
 
     def raft_can_complete_caravan_island(self, player):
         return self.raft_can_access_caravan_island(player) and self.raft_can_craft_ziplineTool(player)
 
     def raft_can_access_tangaroa(self, player):
-        return self.raft_can_complete_caravan_island(player) and self.raft_can_drive(player) and self.has("Tangaroa Frequency", player)
+        return self.raft_can_drive(player) and self.has("Tangaroa Frequency", player)
 
     def raft_can_complete_tangaroa(self, player):
-        return self.raft_can_access_tangaroa(player)
+        return self.raft_can_access_tangaroa(player) and self.raft_can_craft_ziplineTool(player)
 
     def raft_can_access_varuna_point(self, player):
-        return self.raft_can_complete_tangaroa(player) and self.raft_can_drive(player) and self.has("Varuna Point Frequency", player)
+        return self.raft_can_drive(player) and self.has("Varuna Point Frequency", player)
 
     def raft_can_complete_varuna_point(self, player):
-        return self.raft_can_access_varuna_point(player)
+        return self.raft_can_access_varuna_point(player) and self.raft_can_craft_ziplineTool(player)
 
     def raft_can_access_temperance(self, player):
-        return self.raft_can_complete_varuna_point(player) and self.raft_can_drive(player) and self.has("Temperance Frequency", player)
+        return self.raft_can_drive(player) and self.has("Temperance Frequency", player)
 
     def raft_can_complete_temperance(self, player):
-        return self.raft_can_access_temperance(player)
+        return self.raft_can_access_temperance(player) # No zipline required on Temperance
 
     def raft_can_access_utopia(self, player):
-        return self.raft_can_complete_temperance(player) and self.raft_can_drive(player) and self.has("Utopia Frequency", player)
+        return (self.raft_can_drive(player)
+            # Access checks are to prevent frequencies for other
+            # islands from appearing in Utopia
+            and self.raft_can_access_radio_tower(player)
+            and self.raft_can_access_vasagatan(player)
+            and self.raft_can_access_balboa_island(player)
+            and self.raft_can_access_caravan_island(player)
+            and self.raft_can_access_tangaroa(player)
+            and self.raft_can_access_varuna_point(player)
+            and self.raft_can_access_temperance(player)
+            and self.has("Utopia Frequency", player)
+            and self.raft_can_craft_shovel(player)) # Shovels are available but we don't want to softlock players
 
     def raft_can_complete_utopia(self, player):
-        return self.raft_can_access_utopia(player)
+        return self.raft_can_access_utopia(player) and self.raft_can_craft_ziplineTool(player)
 
 def set_rules(world, player):
     regionChecks = {
         "Raft": lambda state: True,
         "ResearchTable": lambda state: True,
         "RadioTower": lambda state: state.raft_can_access_radio_tower(player), # All can_access functions have state as implicit parameter for function
-        "Vasagatan": lambda state: state.raft_can_complete_radio_tower(player) and state.raft_can_access_vasagatan(player),
-        "BalboaIsland": lambda state: state.raft_can_complete_vasagatan(player) and state.raft_can_access_balboa_island(player),
-        "CaravanIsland": lambda state: state.raft_can_complete_balboa_island(player) and state.raft_can_access_caravan_island(player),
-        "Tangaroa": lambda state: state.raft_can_complete_caravan_island(player) and state.raft_can_access_tangaroa(player),
-        "Varuna Point": lambda state: state.raft_can_complete_tangaroa(player) and state.raft_can_access_varuna_point(player),
-        "Temperance": lambda state: state.raft_can_complete_varuna_point(player) and state.raft_can_access_temperance(player),
+        "Vasagatan": lambda state: state.raft_can_access_vasagatan(player),
+        "BalboaIsland": lambda state: state.raft_can_access_balboa_island(player),
+        "CaravanIsland": lambda state: state.raft_can_access_caravan_island(player),
+        "Tangaroa": lambda state: state.raft_can_access_tangaroa(player),
+        "Varuna Point": lambda state: state.raft_can_access_varuna_point(player),
+        "Temperance": lambda state: state.raft_can_access_temperance(player),
         "Utopia": lambda state: state.raft_can_complete_temperance(player) and state.raft_can_access_utopia(player)
     }
     itemChecks = {
@@ -183,7 +196,7 @@ def set_rules(world, player):
         if region != "Menu":
             for exitRegion in world.get_region(region, player).exits:
                 set_rule(world.get_entrance(exitRegion.name, player), regionChecks[region])
-     
+
     # Location access rules
     for location in location_table:
         locFromWorld = world.get_location(location["name"], player)

worlds/raft/__init__.py

@@ -56,21 +56,21 @@ class RaftWorld(World):
         extraItemNamePool = []
         extras = len(location_table) - len(item_table) - 1 # Victory takes up 1 unaccounted-for slot
         if extras > 0:
-            if (self.world.use_resource_packs[self.player].value):
+            if (self.world.filler_item_types[self.player].value != 1): # Use resource packs
                 for packItem in resourcePackItems:
                     for i in range(minimumResourcePackAmount, maximumResourcePackAmount + 1):
                         extraItemNamePool.append(createResourcePackName(i, packItem))
 
-            if self.world.duplicate_items[self.player].value != 0:
+            if self.world.filler_item_types[self.player].value != 0: # Use duplicate items
                 dupeItemPool = item_table.copy()
                 # Remove frequencies if necessary
-                if self.world.island_frequency_locations[self.player].value != 3: # Not completely random locations
+                if self.world.island_frequency_locations[self.player].value != 5: # Not completely random locations
                     dupeItemPool = (itm for itm in dupeItemPool if "Frequency" not in itm["name"])
                 
                 # Remove progression or non-progression items if necessary
-                if (self.world.duplicate_items[self.player].value == 1): # Progression only
+                if (self.world.duplicate_items[self.player].value == 0): # Progression only
                     dupeItemPool = (itm for itm in dupeItemPool if itm["progression"] == True)
-                elif (self.world.duplicate_items[self.player].value == 2): # Non-progression only
+                elif (self.world.duplicate_items[self.player].value == 1): # Non-progression only
                     dupeItemPool = (itm for itm in dupeItemPool if itm["progression"] == False)
                 
                 dupeItemPool = list(dupeItemPool)
@@ -91,19 +91,15 @@ class RaftWorld(World):
 
     def create_regions(self):
         create_regions(self.world, self.player)
-
-    def fill_slot_data(self):
-        slot_data = {}
-        return slot_data
     
     def get_pre_fill_items(self):
-        if self.world.island_frequency_locations[self.player] in [0, 1]:
+        if self.world.island_frequency_locations[self.player] in [0, 1, 2, 3]:
             return [loc.item for loc in self.world.get_filled_locations()]
         return []
     
     def create_item_replaceAsNecessary(self, name: str) -> Item:
         isFrequency = "Frequency" in name
-        shouldUseProgressive = ((isFrequency and self.world.island_frequency_locations[self.player].value == 2)
+        shouldUseProgressive = ((isFrequency and self.world.island_frequency_locations[self.player].value == 4)
             or (not isFrequency and self.world.progressive_items[self.player].value))
         if shouldUseProgressive and name in progressive_table:
             name = progressive_table[name]
@@ -148,6 +144,40 @@ class RaftWorld(World):
             self.setLocationItemFromRegion("Tangaroa", "Varuna Point Frequency")
             self.setLocationItemFromRegion("Varuna Point", "Temperance Frequency")
             self.setLocationItemFromRegion("Temperance", "Utopia Frequency")
+        elif self.world.island_frequency_locations[self.player] in [2, 3]:
+            locationToFrequencyItemMap = {
+                "Vasagatan": "Vasagatan Frequency",
+                "BalboaIsland": "Balboa Island Frequency",
+                "CaravanIsland": "Caravan Island Frequency",
+                "Tangaroa": "Tangaroa Frequency",
+                "Varuna Point": "Varuna Point Frequency",
+                "Temperance": "Temperance Frequency",
+                "Utopia": "Utopia Frequency"
+            }
+            locationToVanillaFrequencyLocationMap = {
+                "RadioTower": "Radio Tower Frequency to Vasagatan",
+                "Vasagatan": "Vasagatan Frequency to Balboa",
+                "BalboaIsland": "Relay Station quest",
+                "CaravanIsland": "Caravan Island Frequency to Tangaroa",
+                "Tangaroa": "Tangaroa Frequency to Varuna Point",
+                "Varuna Point": "Varuna Point Frequency to Temperance",
+                "Temperance": "Temperance Frequency to Utopia"
+            }
+            # Utopia is never chosen until the end, otherwise these are chosen randomly
+            availableLocationList = ["Vasagatan", "BalboaIsland", "CaravanIsland", "Tangaroa", "Varuna Point", "Temperance", "Utopia"]
+            previousLocation = "RadioTower"
+            while (len(availableLocationList) > 0):
+                if (len(availableLocationList) > 1):
+                    currentLocation = availableLocationList[random.randint(0, len(availableLocationList) - 2)]
+                else:
+                    currentLocation = availableLocationList[0] # Utopia (only one left in list)
+                availableLocationList.remove(currentLocation)
+                if self.world.island_frequency_locations[self.player] == 2:
+                    self.setLocationItem(locationToVanillaFrequencyLocationMap[previousLocation], locationToFrequencyItemMap[currentLocation])
+                elif self.world.island_frequency_locations[self.player] == 3:
+                    self.setLocationItemFromRegion(previousLocation, locationToFrequencyItemMap[currentLocation])
+                previousLocation = currentLocation
+
         # Victory item
         self.world.get_location("Utopia Complete", self.player).place_locked_item(
             RaftItem("Victory", ItemClassification.progression, None, player=self.player))
@@ -166,7 +196,8 @@ class RaftWorld(World):
     def fill_slot_data(self):
         return {
             "IslandGenerationDistance": self.world.island_generation_distance[self.player].value,
-            "ExpensiveResearch": self.world.expensive_research[self.player].value
+            "ExpensiveResearch": bool(self.world.expensive_research[self.player].value),
+            "DeathLink": bool(self.world.death_link[self.player].value)
         }
 
 def create_region(world: MultiWorld, player: int, name: str, locations=None, exits=None):

worlds/raft/docs/en_Raft.md

@@ -22,7 +22,7 @@ Decoration Packages are unchanged.
 Researches and pickups remain visually unchanged, regardless of what the unlock is.
 
 ## When the player receives an item, what happens?
-A Raft notification will appear with the item information. The unlock will also appear in the chat. Unlocks that would normally give you the item (eg Machete) will NOT give it to you, but must instead be crafted.
+A Raft notification will appear with the item information. The unlock will also appear in the chat. Unlocks that would normally give you the item (eg Zipline) will NOT give it to you, but must instead be crafted.
 
 ## Are there any limitations compared to vanilla Raft?
 - Mods that add new researchable technologies, modify story islands, or give items like blueprints are likely incompatible with Raftipelago.