merge main

.github/workflows/build.yml

@@ -9,12 +9,14 @@ on:
       - 'setup.py'
       - 'requirements.txt'
       - '*.iss'
+      - 'worlds/*/archipelago.json'
   pull_request:
     paths:
       - '.github/workflows/build.yml'
       - 'setup.py'
       - 'requirements.txt'
       - '*.iss'
+      - 'worlds/*/archipelago.json'
   workflow_dispatch:
 
 env:

.github/workflows/docker.yml

@@ -0,0 +1,154 @@
+name: Build and Publish Docker Images
+
+on:
+  push:
+    paths:
+      - "**"
+      - "!docs/**"
+      - "!deploy/**"
+      - "!setup.py"
+      - "!.gitignore"
+      - "!.github/workflows/**"
+      - ".github/workflows/docker.yml"
+    branches:
+      - "*"
+    tags:
+      - "v?[0-9]+.[0-9]+.[0-9]*"
+  workflow_dispatch:
+
+env:
+  REGISTRY: ghcr.io
+
+jobs:
+  prepare:
+    runs-on: ubuntu-latest
+    outputs:
+      image-name: ${{ steps.image.outputs.name }}
+      tags: ${{ steps.meta.outputs.tags }}
+      labels: ${{ steps.meta.outputs.labels }}
+      package-name: ${{ steps.package.outputs.name }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set lowercase image name
+        id: image
+        run: |
+          echo "name=${GITHUB_REPOSITORY,,}" >> $GITHUB_OUTPUT
+
+      - name: Set package name
+        id: package
+        run: |
+          echo "name=$(basename ${GITHUB_REPOSITORY,,})" >> $GITHUB_OUTPUT
+
+      - name: Extract metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ steps.image.outputs.name }}
+          tags: |
+            type=ref,event=branch,enable={{is_not_default_branch}}
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=raw,value=nightly,enable={{is_default_branch}}
+
+      - name: Compute final tags
+        id: final-tags
+        run: |
+          readarray -t tags <<< "${{ steps.meta.outputs.tags }}"
+
+          if [[ "${{ github.ref_type }}" == "tag" ]]; then
+            tag="${{ github.ref_name }}"
+            if [[ "$tag" =~ ^v?[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+              full_latest="${{ env.REGISTRY }}/${{ steps.image.outputs.name }}:latest"
+              # Check if latest is already in tags to avoid duplicates
+              if ! printf '%s\n' "${tags[@]}" | grep -q "^$full_latest$"; then
+                tags+=("$full_latest")
+              fi
+            fi
+          fi
+
+          # Set multiline output
+          echo "tags<<EOF" >> $GITHUB_OUTPUT
+          printf '%s\n' "${tags[@]}" >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT
+
+  build:
+    needs: prepare
+    runs-on: ${{ matrix.runner }}
+    permissions:
+      contents: read
+      packages: write
+    strategy:
+      matrix:
+        include:
+          - platform: amd64
+            runner: ubuntu-latest
+            suffix: amd64
+            cache-scope: amd64
+          - platform: arm64
+            runner: ubuntu-24.04-arm
+            suffix: arm64
+            cache-scope: arm64
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Compute suffixed tags
+        id: tags
+        run: |
+          readarray -t tags <<< "${{ needs.prepare.outputs.tags }}"
+          suffixed=()
+          for t in "${tags[@]}"; do
+            suffixed+=("$t-${{ matrix.suffix }}")
+          done
+          echo "tags=$(IFS=','; echo "${suffixed[*]}")" >> $GITHUB_OUTPUT
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./Dockerfile
+          platforms: linux/${{ matrix.platform }}
+          push: true
+          tags: ${{ steps.tags.outputs.tags }}
+          labels: ${{ needs.prepare.outputs.labels }}
+          cache-from: type=gha,scope=${{ matrix.cache-scope }}
+          cache-to: type=gha,mode=max,scope=${{ matrix.cache-scope }}
+          provenance: false
+
+  manifest:
+    needs: [prepare, build]
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - name: Log in to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Create and push multi-arch manifest
+        run: |
+          readarray -t tag_array <<< "${{ needs.prepare.outputs.tags }}"
+
+          for tag in "${tag_array[@]}"; do
+            docker manifest create "$tag" \
+              "$tag-amd64" \
+              "$tag-arm64"
+
+            docker manifest push "$tag"
+          done

.github/workflows/label-pull-requests.yml

@@ -12,7 +12,6 @@ env:
 jobs:
   labeler:
     name: 'Apply content-based labels'
-    if: github.event.action == 'opened' || github.event.action == 'reopened' || github.event.action == 'synchronize'
     runs-on: ubuntu-latest
     steps:
       - uses: actions/labeler@v5

.github/workflows/release.yml

@@ -5,7 +5,7 @@ name: Release
 on:
   push:
     tags:
-      - '*.*.*'
+      - 'v?[0-9]+.[0-9]+.[0-9]*'
 
 env:
   ENEMIZER_VERSION: 7.1

.run/Build APWorld.run.xml

@@ -0,0 +1,24 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Build APWorld" type="PythonConfigurationType" factoryName="Python">
+    <module name="Archipelago" />
+    <option name="ENV_FILES" value="" />
+    <option name="INTERPRETER_OPTIONS" value="" />
+    <option name="PARENT_ENVS" value="true" />
+    <envs>
+      <env name="PYTHONUNBUFFERED" value="1" />
+    </envs>
+    <option name="SDK_HOME" value="" />
+    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/" />
+    <option name="IS_MODULE_SDK" value="true" />
+    <option name="ADD_CONTENT_ROOTS" value="true" />
+    <option name="ADD_SOURCE_ROOTS" value="true" />
+    <option name="SCRIPT_NAME" value="$ContentRoot$/Launcher.py" />
+    <option name="PARAMETERS" value="\&quot;Build APWorlds\&quot;" />
+    <option name="SHOW_COMMAND_LINE" value="false" />
+    <option name="EMULATE_TERMINAL" value="false" />
+    <option name="MODULE_MODE" value="false" />
+    <option name="REDIRECT_INPUT" value="false" />
+    <option name="INPUT_FILE" value="" />
+    <method v="2" />
+  </configuration>
+</component>

BaseClasses.py

@@ -261,6 +261,7 @@ def set_item_links(self):
                         "local_items": set(item_link.get("local_items", [])),
                         "non_local_items": set(item_link.get("non_local_items", [])),
                         "link_replacement": replacement_prio.index(item_link["link_replacement"]),
+                        "skip_if_solo": item_link.get("skip_if_solo", False),
                     }
 
         for _name, item_link in item_links.items():
@@ -284,6 +285,8 @@ def set_item_links(self):
 
         for group_name, item_link in item_links.items():
             game = item_link["game"]
+            if item_link["skip_if_solo"] and len(item_link["players"]) == 1:
+                continue
             group_id, group = self.add_group(group_name, game, set(item_link["players"]))
 
             group["item_pool"] = item_link["item_pool"]
@@ -1343,8 +1346,7 @@ def get_connecting_entrance(self, is_main_entrance: Callable[[Entrance], bool])
         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 add_locations(self, locations: Dict[str, Optional[int]],
-                      location_type: Optional[type[Location]] = None) -> None:
+    def add_locations(self, locations: Mapping[str, int | None], location_type: type[Location] | None = None) -> None:
         """
         Adds locations to the Region object, where location_type is your Location class and locations is a dict of
         location names to address.
@@ -1432,16 +1434,16 @@ def create_er_target(self, name: str) -> Entrance:
         entrance.connect(self)
         return entrance
 
-    def add_exits(self, exits: Union[Iterable[str], Dict[str, Optional[str]]],
-                  rules: Dict[str, Callable[[CollectionState], bool]] = None) -> List[Entrance]:
+    def add_exits(self, exits: Iterable[str] | Mapping[str, str | None],
+                  rules: Mapping[str, Callable[[CollectionState], bool]] | None = None) -> List[Entrance]:
         """
         Connects current region to regions in exit dictionary. Passed region names must exist first.
 
         :param exits: exits from the region. format is {"connecting_region": "exit_name"}. if a non dict is provided,
                       created entrances will be named "self.name -> connecting_region"
         :param rules: rules for the exits from this region. format is {"connecting_region": rule}
         """
-        if not isinstance(exits, Dict):
+        if not isinstance(exits, Mapping):
             exits = dict.fromkeys(exits)
         return [
             self.connect(
@@ -1855,6 +1857,9 @@ def write_option(option_key: str, option_obj: Options.AssembleOptions) -> None:
                     Utils.__version__, self.multiworld.seed))
             outfile.write('Filling Algorithm:               %s\n' % self.multiworld.algorithm)
             outfile.write('Players:                         %d\n' % self.multiworld.players)
+            if self.multiworld.players > 1:
+                loc_count = len([loc for loc in self.multiworld.get_locations() if not loc.is_event])
+                outfile.write('Total Location Count:            %d\n' % loc_count)
             outfile.write(f'Plando Options:                  {self.multiworld.plando_options}\n')
             AutoWorld.call_stage(self.multiworld, "write_spoiler_header", outfile)
 
@@ -1863,6 +1868,9 @@ def write_option(option_key: str, option_obj: Options.AssembleOptions) -> None:
                     outfile.write('\nPlayer %d: %s\n' % (player, self.multiworld.get_player_name(player)))
                 outfile.write('Game:                            %s\n' % self.multiworld.game[player])
 
+                loc_count = len([loc for loc in self.multiworld.get_locations(player) if not loc.is_event])
+                outfile.write('Location Count:                  %d\n' % loc_count)
+
                 for f_option, option in self.multiworld.worlds[player].options_dataclass.type_hints.items():
                     write_option(f_option, option)
 

CommonClient.py

@@ -99,17 +99,6 @@ def _cmd_received(self) -> bool:
             self.ctx.on_print_json({"data": parts, "cmd": "PrintJSON"})
         return True
 
-    def get_current_datapackage(self) -> dict[str, typing.Any]:
-        """
-        Return datapackage for current game if known.
-
-        :return: The datapackage for the currently registered game. If not found, an empty dictionary will be returned.
-        """
-        if not self.ctx.game:
-            return {}
-        checksum = self.ctx.checksums[self.ctx.game]
-        return Utils.load_data_package_for_checksum(self.ctx.game, checksum)
-
     def _cmd_missing(self, filter_text = "") -> bool:
         """List all missing location checks, from your local game state.
         Can be given text, which will be used as filter."""
@@ -119,8 +108,8 @@ def _cmd_missing(self, filter_text = "") -> bool:
         count = 0
         checked_count = 0
 
-        lookup = self.get_current_datapackage().get("location_name_to_id", {})
-        for location, location_id in lookup.items():
+        lookup = self.ctx.location_names[self.ctx.game]
+        for location_id, location in lookup.items():
             if filter_text and filter_text not in location:
                 continue
             if location_id < 0:
@@ -141,11 +130,10 @@ def _cmd_missing(self, filter_text = "") -> bool:
             self.output("No missing location checks found.")
         return True
 
-    def output_datapackage_part(self, key: str, name: str) -> bool:
+    def output_datapackage_part(self, name: typing.Literal["Item Names", "Location Names"]) -> bool:
         """
         Helper to digest a specific section of this game's datapackage.
 
-        :param key: The dictionary key in the datapackage.
         :param name: Printed to the user as context for the part.
 
         :return: Whether the process was successful.
@@ -154,23 +142,20 @@ def output_datapackage_part(self, key: str, name: str) -> bool:
             self.output(f"No game set, cannot determine {name}.")
             return False
 
-        lookup = self.get_current_datapackage().get(key)
-        if lookup is None:
-            self.output("datapackage not yet loaded, try again")
-            return False
-
+        lookup = self.ctx.item_names if name == "Item Names" else self.ctx.location_names
+        lookup = lookup[self.ctx.game]
         self.output(f"{name} for {self.ctx.game}")
-        for key in lookup:
-            self.output(key)
+        for name in lookup.values():
+            self.output(name)
         return True
 
     def _cmd_items(self) -> bool:
         """List all item names for the currently running game."""
-        return self.output_datapackage_part("item_name_to_id", "Item Names")
+        return self.output_datapackage_part("Item Names")
 
     def _cmd_locations(self) -> bool:
         """List all location names for the currently running game."""
-        return self.output_datapackage_part("location_name_to_id", "Location Names")
+        return self.output_datapackage_part("Location Names")
 
     def output_group_part(self, group_key: typing.Literal["item_name_groups", "location_name_groups"],
                           filter_key: str,
@@ -871,9 +856,9 @@ async def server_loop(ctx: CommonContext, address: typing.Optional[str] = None)
 
     server_url = urllib.parse.urlparse(address)
     if server_url.username:
-        ctx.username = server_url.username
+        ctx.username = urllib.parse.unquote(server_url.username)
     if server_url.password:
-        ctx.password = server_url.password
+        ctx.password = urllib.parse.unquote(server_url.password)
 
     def reconnect_hint() -> str:
         return ", type /connect to reconnect" if ctx.server_address else ""

Fill.py

@@ -129,6 +129,10 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
                                      for i, location in enumerate(placements))
                     for (i, location, unsafe) in swap_attempts:
                         placed_item = location.item
+                        if item_to_place == placed_item:
+                            # The number of allowed swaps is limited, so do not allow a swap of an item with a copy of
+                            # itself.
+                            continue
                         # Unplaceable items can sometimes be swapped infinitely. Limit the
                         # number of times we will swap an individual item to prevent this
                         swap_count = swapped_items[placed_item.player, placed_item.name, unsafe]